A Cluster-Tree-Based Secure Routing Protocol Using Dragonfly Algorithm (DA) in the Internet of Things (IoT) for Smart Agriculture

Abstract

The Internet of Things defines a global and comprehensive network whose task is to monitor and control the physical world by collecting, processing, and analyzing data sensed by IoT devices. This network has succeeded in various areas, and one of its most important applications is in smart agriculture because there are many demands for producing high-quality foodstuff in the world. These demands need new production schemes in the agriculture area. In IoT, communication security is essential due to the extensive heterogeneity of IoT devices. In this paper, a cluster-tree-based secure routing approach using the dragonfly algorithm (CTSRD) is proposed for IoT. The proposed scheme presents a distributed and lightweight trust mechanism called weighted trust (W-Trust). W-Trust reduces the trust value corresponding to malicious nodes based on a penalty coefficient to isolate this node in the network. Furthermore, it improves the trust value of honest IoT devices based on a reward coefficient. Additionally, CTSRD introduces a trust-based clustering process called T-Clustering. In this clustering process, cluster head nodes (CHs) are selected among honest IoT nodes. Finally, CTSRD establishes a routing tree based on the dragonfly algorithm (DA) between CHs. This tree is called DA-Tree. To evaluate the quality of the routing tree, a new fitness function is provided in CTSRD. DA-Tree finds a secure, stable, and optimal routing tree to balance the consumed energy and boost the network lifetime. CTSRD is compared with EEMSR and E-BEENISH with regard to the network lifetime, consumed energy, and packet delivery rate. This comparison shows that our scheme can uniformly distribute the consumed energy in IoT and improves the energy consumption and network lifetime. However, it has a slightly lower packet delivery rate than EEMSR.

1. Introduction

Today, the Internet of Things (IoT) is a special subject. In recent years, the number of smart devices and wireless sensors connected to IoT have grown significantly. Gartner estimates that the number of IoT devices connected to the Internet was higher than 25 billion in 2021 [1]. Furthermore, Cisco predicted that there will be 75 billion devices connected to the Internet by 2025 [2]. Another prediction in [3] stated that 50 billion IoT devices will be in use around the world by 2030. In IoT, devices process and transfer data through intelligent sensors without human intervention [4]. As a result, sensor nodes are one of the main components of the Internet of Things. Wireless sensor networks (WSNs) provide a framework for managing sensor nodes [5,6]. In WSN-based IoT, a number of sensor nodes work together to monitor the environment. They are connected to the Internet via the base station or sink node. Sensor nodes used in WSN-based IoT networks have many restrictions on energy sources, radio range, and processing power. Given that achieving the longest lifetime is a very important issue in these networks, the main challenge in these networks is to save the energy of sensor nodes [7,8].

IoT can be used in many areas, for example, healthcare, smart transportation, smart homes, smart cities, and smart factories. One of its most important applications is smart agriculture. For example, Cropx uses the Internet of Things in agriculture [9]. The company has installed sensors to manage water consumption in agricultural lands. It has developed tools for managing the use of pesticides and fertilizers and collecting information about soil and air quality using algorithms and machine learning techniques. This technology has revolutionized the agricultural field because it provides a set of various tools for farmers to address the many challenges it presents. Farmers can be connected to their farmland equipped with IoT devices from anywhere and at any time [10,11]. IoT-based technologies can potentially reduce the production cost of agricultural products and increase farmland productivity. Smart agriculture utilizes sensors and actuators to regulate and monitor agricultural processes. IoT sensors can measure soil temperature, NPK, water content, photosynthetic radiation, soil–water conditions, and soil oxygen level [12,13]. Water management, irrigation management systems, soil monitoring, climate management, precision agriculture, and waste management are the most important sections that can be improved by IoT in smart agriculture [13,14]. See Figure 1.

Due to the extension of IoT networks around the world and the heterogeneity of IoT devices, routing and secure data transfer through IoT sensors are very important in IoT-based smart agriculture. Usually, IoT sensors have constraints on resources, computing power, and memory [15,16,17]. As a result, each secure routing method must be lightweight and efficient [18,19,20]. The research studies show that many researchers have separately researched and studied communication security and energy efficiency in IoT networks but energy-efficient secure methods have received less attention because security and energy efficiency have an inverse relationship with each other [21,22]. Robust security mechanisms consume a lot of energy. However, most IoT nodes suffer from limited resources, especially energy. For this reason, the design of an energy-efficient secure routing approach is a serious challenge in IoT [23,24,25]. To achieve both security and energy efficiency in the data transmission process, researchers must focus on energy-efficient secure routing schemes and design lightweight security mechanisms for Internet of Things so that they are compatible with the specific characteristics of these networks [26,27,28].

In this paper, a cluster-tree-based energy-efficient secure routing protocol using the dragonfly algorithm (CTSRD) is proposed for IoT networks. The goal of this approach is to enhance security and achieve energy efficiency simultaneously. CTSRD is a hierarchical routing algorithm, which includes two operations: secure clustering (T-Clustering) and a dragonfly algorithm-based routing tree (DA-Tree). Furthermore, the trust mechanism presented in this paper can be a suitable defense mechanism against black hole attacks. In the following, the contributions of this paper are briefly introduced:

• CTSRD provides a distributed and lightweight trust mechanism called weighted trust (W-Trust). This mechanism evaluates the trust value of IoT nodes in accordance with interactions between them and other nodes. If W-Trust detects the abnormal behavior of an IoT node, it quickly reduces the direct trust value related to this node based on a penalty factor to avoid its hostile activities in the network. On the other hand, if W-Trust detects the normal behavior of a node, it improves the trust level of this node based on a reward factor to increase the participation probability of this node in the routing process.
• CTSRD introduces a trust-based clustering method called T-Clustering. In this clustering process, cluster head nodes (CHs) are selected from honest nodes. Note that clustering reduces communication overhead and energy consumption, improves the packet delivery rate (PDR), and lowers delay in the data transfer process. In CTSRD, nodes that are closer to the cluster center and have a higher energy and neighbor degree, and are closer to the sink node, and increase their chance of becoming the cluster head.
• CTSRD forms a routing tree based on the dragonfly algorithm (DA-Tree) between the cluster head nodes. The DA-Tree provides a fitness function for evaluating the routing tree. The parameters used in the fitness function include the number of hops to the base station, remaining energy, intra-cluster traffic, and the trust value. This algorithm finds an optimal, stable, and secure routing tree, and consequently makes a balanced energy distribution in the network.
• Finally, CTSRD is compared with EEMSR and E-BEENISH in terms of network lifetime, energy consumption, and packet delivery ratio. This comparison shows that CTSRD evenly distributes the consumed energy in IoT and prolongs the network lifetime. However, it has a slightly lower PDR than EEMSR.

Other sections of this paper are arranged as follows: Section 2 illustrates some research works in this area and their advantages and disadvantages. Section 3 explains the dragonfly algorithm used in CTSRD. Section 4 states the network model, energy model, and attack model applied in CTSRD. Section 5 explains our scheme in detail. Section 6 simulates CTSRD and analyzes its results. Section 7 concludes the paper.

2. Related Works

In [29], an energy-efficient multi-level secure routing (EEMSR) technique is proposed to extend IoT applications and reach the best performance. EEMSR has simultaneously focused on two important issues in IoT, i.e., energy efficiency and security. EEMSR utilizes the clustering technique because it is a useful solution for increasing energy efficiency and enhancing scalability. In addition, the authors used two techniques, namely the analytic hierarchy process (AHP) and improved genetic algorithm (GA), to specify the exact weight of IoT nodes for selecting CHs and determine the optimal path between CHs, respectively. In addition, EEMSR provides several trust levels (i.e., data perception, data aggregation, and connection levels) to protect the network against various attacks. The experiment results prove that EEMSR provides energy efficiency and network security.

In [30], the authors analyzed the consumed energy within clusters in heterogeneous WSNs and proposed the E-BEENISH routing approach. This scheme defines the CH selection process in accordance with the weighted selection probability specified for each node. This probability is dependent on remaining energy and the distance between the base station (BS) and the node. Additionally, E-BEENISH investigates the effect associated with the heterogeneity of the energy status of nodes. E-BEENISH picks out CHs based on various scales such as the distance parameter, the average network energy, and the remaining energy. Furthermore, this method utilizes a normalized weighted value to prolong the network lifetime. According to the simulation results, E-BEENISH has improved the system lifetime compared to existing clustering protocols. It is a critical parameter for many applications.

In [31], the authors presented a QoS-based secure routing approach called MCEAACO-QSRP in IoT. This scheme initializes the primary population based on a chaotic optimization strategy. The purpose of this technique is to enhance its diversity. As a result, the algorithm is not trapped in the local optimum. For dynamic pheromone tuning and updating, MCEAACO-QSRP supports an adaptive optimization strategy to effectively accelerate the convergence of the algorithm by lowering iterations. This optimizes energy consumption. Furthermore, MCEAACO-QSRP introduces a secure QoS-based routing framework based on a trust model to protect against black hole attacks. It computes the trust value with regard to the successful behavior of nodes when exchanging (i.e., sending/receiving) data packets. Finally, it is used to detect normal and abnormal nodes. The experimental results confirm that MCEAACO-QSRP can simultaneously optimize security and energy consumption. This meets multiple QoS requirements, for example, it lowers latency and provides reliable services to users.

In [32], a chaotic bumble bee mating optimization (CBBMO) algorithm is suggested to securely transfer data packets. The security is guaranteed using a trust structure called CBBMOR-TSM. The authors combine the chaotic concept with CBBMO to accelerate its convergence rate. In the first step, the trust structure is obtained from both indirect and direct trusts. This structure is applied to specify the trust value of IoT nodes. As a result, this structure helps CBBMOR-TSM detect and isolate malicious nodes. Moreover, this structure can be used to specify suitable and secure paths for transmitting data packets. According to the simulation results, this method can lower the delay and consumed energy and enhance the data transfer rate when there are hostile nodes in the network.

In [33], an energy-aware trust-based efficient routing scheme (ETERS) is offered for a clustered network. This approach provides a multi-trust solution, including communication, energy, and data trusts to deal with various attacks, for example, badmouthing, Sybil, Grey hole, on–off, and black hole. Furthermore, ETERS presents a CH selection process called ECHSA, which builds a load balance between all CHs. In ETERS, the trust function is defined based on the $\beta$ distribution. Moreover, this scheme has an irregular attenuation factor when evaluating communication trust. This factor shows the effect of various external elements, for example, earthquakes or network congestion. In ETERS, an attack detection algorithm called TADA analyzes the reliability of the nodes. It depends on three scales, namely ID, location, and the trust solution. Note that the trust solution applies a timing window with variable length to eliminate some constraints of existing trust mechanisms. ETERS designs a secure routing technique based on the proposed trust solution to form an energy-efficient connection between network nodes. The simulation results show that ETERS has a successful performance in terms of PDR, consumed energy, and latency.

In [34], an RPL-based secure routing protocol called SPRL is offered. It focuses on the rank manipulation issue. For solving this issue, SPRL defines a novel concept called rank threshold and a hash chain-based authentication mechanism. The purpose of these techniques is to control the change rate of the rank value. Now, if the hostile nodes carry out internal attacks by changing the rank value, SPRL does not allow them to change their positions on the destination-oriented directed acyclic graph (DODAG) in the RPL network. To reduce the effect of the attack, this scheme defines a threshold function to check the rank value in RPL. SPRL protects RPL against the rank manipulation attack based on these threshold functions. In addition, an authentication concept is introduced in SPRL to provide better security. In the authentication process, each node earns a rank threshold. The simulation results show that SPRL can protect the RPL network, but this scheme is unsuitable for some attacks. In this scheme, thresholds are defined for all nodes, i.e., malicious or normal nodes. This causes additional overhead.

In [35], a trust-aware routing scheme called SecTrust-RPL is introduced for IoT networks. It is suitable for protecting the IoT network against both rank and Sybil attacks. SecTrust-RPL is responsible for performing two operations, namely the attack detection and the malicious node isolation. In the first step, each IoT node obtains its trust with regard to the direct trust and the trust recommended by its neighbors. Neighboring IoT devices with a bigger trust value are chosen to execute the secure routing operation. In contrast, neighboring IoT devices that obtain a lower trust value are considered malicious nodes or selfish nodes. This method allows trusted nodes to form safe communication only with other trusted nodes. Moreover, trust information is shared with neighboring IoT nodes in the network. SecTrust-RPL validates the trust of each transmitter node to secure the data transmission path. The simulation results show that SecTrust-RPL resists rank attacks. However, it does not consider the uncertainty in the recommendations.

In [36], an energy harvesting trust-aware routing approach (EHTARA) is provided to design a trust-based routing framework in IoT. EHTARA determines the most suitable route based on a cost parameter, which depends on factors such as energy, distance, and trust. The base station classifies big data using the deep belief network (DBN). In EHTARA, this network is trained based on the E-Bat algorithm, which integrates the exponential weighted moving average (EWMA) and the bat algorithm (BA). The purpose of this technique is to choose a node with the maximum remaining energy and the lowest link cost. This work is performed based on the shortest route technique. Furthermore, EHTARA specifies suitable paths for the data transmission process using energy harvesting parameters. It consumes energy efficiently.

In [37], a trust-based secure routing approach called SMTrust is suggested in the Internet of Things. This scheme is suitable for IoT with constrained sources. SMTrust deals with rank and blackhole attacks because these negatively affect the routing process. It is presented in two modes, including fixed and mobile nodes. SMTrust finds trust scales and examines whether these scales are suitable for enhancing security in RPL. The authors combine SMTrust and RPL to optimize the network performance because this trust-based approach identifies and isolates malicious nodes. The performance of this protocol has been evaluated in accordance with topology stability, packet loss, throughput, and consumed energy. This evaluation proves its success in comparison with other methods.

In [38], a deep learning (DL)-based trusted routing approach is presented for the industrial IoT (IIoT). This network suffers from vulnerabilities at different levels. Thus, the learning process must be reliable. The authors have trained an adversarial model to identify the desired attacks in RPL. Therefore, a trusted learning model is established. Moreover, a generative adversarial network classifier (GAN-C) is created using GAN and support vector machines (SVM). The performance of GAN-C is analyzed based on SVM. In this technique, real data and noise data are separated to identify an attack. Then, different attacks are assigned to the corresponding classes in RPL to prevent their effect on the network performance. This supports two deep learning features, namely a parallel learning and detection model. When various attacks are detected timely, it reduces the packet loss and latency in the data transmission process. The parallel model has been analyzed, and decentralized and centralized attack detection systems are compared to the RPL network. GAN-C, which is a parallel model, has a significant reduction in training time.

In [39], a trust-based secure energy-efficient routing scheme (TBSEER) is offered. It acquires the total trust based on three scales, namely direct trust, indirect trust, and energy trust. This technique deals with black hole, Grey hole, sink hole, and flooding attacks. It defines an adaptive penalty mechanism and a volatilization scale to quickly identify the abnormal nodes in TBSEER. In this mechanism, nodes only obtain the direct trust, and the task of BS is to calculate the indirect trust. This lowers the consumed energy caused by repeated computations. Finally, CHs must find secure multi-hop paths according to the total trust to prevent the wormhole attack. The experiment results confirms that TBSEER consumes low energy in the network, quickly identifies abnormal nodes, and resists common attacks.

Table 1. Comparison of different techniques and examination of their strengths and weaknesses.

Technique	Security Mechanism	Energy Efficiency	Strengths	Weaknesses
EEMSR [29]	✓	✓	Presenting a robust and efficient trust technique, balancing energy consumption, improving network lifetime, increasing reliability, enhancing security, high scalability, reducing latency, high data transmission rate when there are malicious nodes	High time complexity and computational complexity
E-BEENISH [30]	×	✓	Reducing energy consumption, improving network lifetime, high scalability, improving the data transmission rate	Not having a strong security mechanism for dealing with network attacks, low reliability
MCEAACO-QSRP [31]	✓	✓	Lowering energy consumption, providing secure services in the network, reducing end-to-end delay, improving the trust value, and increasing the data transmission rate under black hole attacks	Low scalability, flat network model
CBBMOR-TSM [32]	✓	×	Using a robust trust mechanism, increasing the data transmission rate, lowering energy consumption and latency in the network despite black hole and DDoS attacks, suitable throughput	Low scalability, flat network model
ETERS [33]	✓	✓	Designing a strong trust technique, high scalability, suitable throughput, acceptable packet delivery rate, optimal energy consumption, acceptable latency, resistance against some attacks, easy implementation	High time complexity and computational complexity
SPRL [34]	✓	×	Protecting against some attacks, low latency	High overhead
SecTrust-RPL [35]	✓	×	Lowering communication overhead, protecting against rank and Sybil attacks, performing both attack detection and malicious node isolation	Not considering the uncertainty in the recommendations
EHTARA [36]	✓	✓	Improving energy consumption, managing the data transmission process between nodes, presenting a trust-based data transmission process	Not providing an accurate and certain security analysis, not determining how to deal with network attacks
SMTrust [37]	✓	×	High data transmission rate and reliability, improving throughput, designing security mechanism for detecting black hole and rank attacks	Flat network model, low scalability, low communication overhead, high latency
GAN-C [38]	✓	×	Timely attack detection, decreasing latency, and packet loss	High time complexity and computational complexity, high routing overhead, low scalability
TBSEER [39]	✓	✓	Decreasing energy consumption, improving network security, designing a robust trust mechanism, ability to identify various attacks, low latency and packet loss, high scalability	High routing overhead
CTSRD	✓	✓	Presenting a robust and energy-efficient routing technique, evenly distributing the consumed energy between the network nodes, enhancing energy consumption, and network lifetime	Low packet delivery rate

compares various security techniques mentioned in this section and emphasizes their strengths and weaknesses. Our research studies show that many researchers have separately studied communication security and energy efficiency in IoT networks but energy-efficient secure methods have received less attention. Robust security mechanisms, for example CBBMOR-TSM [32], SPRL [34], SecTrust-RPL [35], SMTrust [37], and GAN-C [38], consume a lot of energy. In this case, IoT nodes suffer from limited resources, especially energy. For this reason, energy-efficient secure routing protocols such as EEMSR [29], MCEAACO-QSRP [31], ETERS [33], EHTARA [36], and TBSEER [39] provide security and energy efficiency simultaneously. Thus, we propose a cluster-tree-based energy-efficient secure routing protocol using the dragonfly algorithm (CTSRD) in IoT networks. This approach considers network security and energy efficiency simultaneously. CTSRD is a hierarchical routing algorithm, which includes two operations: secure clustering (T-Clustering) and a dragonfly algorithm-based routing tree (DA-Tree). Furthermore, CTSRD provides a distributed and lightweight trust mechanism called weighted trust (W-Trust) to evaluate the trust level of IoT nodes in the network.

3. Basic Concepts

In the proposed method, a metaheuristic dragonfly algorithm (DA) [40] has been used to improve the routing process in IoT. Recently, metaheuristic algorithms can effectively solve many complex problems, especially routing in IoT because they have important features such as self-organization, parallel operation, distributed operation, flexibility, and stability. Various research studies show that metaheuristic-based routing techniques have advantages compared to classical routing approaches. The main advantage is their ability to perform a relatively large search. In these methods, the solutions obtained at each iteration of the search process are modified to obtain the optimal solution. Moreover, to produce the optimal response, these routing methods usually provide good exploration and exploitation capabilities. Accordingly, metaheuristic routing methods operate in a distributed manner and without any central control. This means that if any part of this system fails for some reason, this does not damage the whole system and provides good stability. In the following, the dragonfly algorithm (DA) is briefly illustrated because CTSRD uses this algorithm to build the routing tree (DA-Tree) between CHs. The purpose of choosing DA is its ability to reach the global optimum, acceptable convergence speed, and high accuracy. Furthermore, DA can effectively balance global and local search processes.

Table 2. Comparison of meta-heuristic algorithms.

Algorithm	Description	Properties
		Convergence Rate	Accuracy	Execution Time	Implementation	Ability to Reach the Global Optimum	Local Optimum Issue	Trade-Off between Local and Global Searches
DA [40]	This algorithm simulates the social behavior of dragonflies in the nature. It utilizes a high convergence rate.	High	High	Short	Simple	Good	No	Good
GWO [41]	This algorithm simulates the hunting behavior of gray wolves. It is simple and efficiently solves large and complex issues.	High	Low	Short	Simple	Bad	Yes	Bad
BA [42]	It simulates the feeding behavior of bats. It is efficient and regularity adjusts its factors.	High	Low	Short	Simple	Bad	Yes	Almost good
PSO [43]	It simulates the social life of birds. It needs the storage capacity to maintain the global optimum and the local optimum in each particle.	High	Low	Short	Simple	Almost good	Yes	Almost good
GA [44]	It is presented to simulate the gene evolution.	High	Medium	Long	Simple	Almost good	Yes	Good
FA [45]	It simulates the brightness behavior of fireflies. FA depends on two principles, namely light intensity and attractiveness.	High	High	High	Simple	Almost good	No	Good

briefly evaluates DA and other metaheuristic algorithms. The DA algorithm is rooted in the behavior of dragonflies in nature. In 2016, it was introduced by Seyed Ali Mirjalili. Dragonflies move in static and dynamic swarms, and this behavior is simulated in DA. When dragonflies are organized into small groups and move to various regions in the search area, this organization is called a static swarm. The exploration phase is formed by modeling this static swarm in nature. In contrast, when a dynamic swarm is created, dragonflies are organized in larger groups and move in a certain direction in the search area. The exploitation phase can be defined by simulating the dynamic swarm of dragonflies in nature. Artificial dragonflies refresh their position with regard to the step vector $(\Delta x)$ and the position vector $\left(x\right)$ in each iteration. $\Delta x$ is calculated based on Equation (1):

$$\Delta X_{t+1}=\omega \Delta X_t+\left(s{S}_i+a{A}_i+c{C}_i+f{F}_i+e{E}_i\right)$$

(1)

where i indicates the index of the dragonfly. s represents a weight coefficient for the separation value ($S_i$). a expresses the weight factor of the alignment parameter ($A_i$). c indicates the weight coefficient of the cohesion value ($C_i$) related to the i-th dragonfly. f illustrates the weight related to the food source $F_i$ (the most suitable response explored in the former iteration). e is the weight corresponding to the enemy $E_i$ (the worst response explored in the previous iteration). Finally, $\omega$ and t are the inertial weight and the iteration number, respectively.

Finally, the position vectors of dragonflies are obtained from Equation (2):

$$X_{t+1}=X_t+\Delta X_{t+1}$$

(2)

where t indicates the number of iterations. For performing a more detailed study and acquiring accurate information about the dragonfly algorithm, refer to [40].

4. System Model

The system model consists of four main parts: the network model, the energy model, the attack model, and the trust model.

4.1. Network Model

In CTSRD, the network model is a WSN-based IoT network. The network includes N heterogeneous sensor nodes that work together to monitor the environment. They are connected to the Internet via the base station or sink node. A unique ID is allocated to each node, and the deployment of IoT nodes is performed in a random manner. Furthermore, a positioning device such as the global positioning system (GPS) is embedded in all IoT nodes to obtain their position in the network. IoT nodes differ in energy level, computing power, and memory capacity. In this network, the nodes have different roles: cluster head nodes (CHs) and cluster member nodes (CMs). See Figure 2. In the following, a summary of the task related to each node is described:

• Cluster member nodes: The task of CMs is to obtain data from the desired area and forward it to CH using a direct connection.
• Cluster head nodes: The task of CHs is to receive data from CMs, aggregate these data packets, and transfer them to the base station. CHs use a binary routing tree to transfer data to the BS.
• Basic station: The main task of BS is to process, analyze, and decide on data received from CHs. The position of the base station is fixed and pre-defined for all IoT nodes.

4.2. Energy Model

Sending and receiving data have maximum consumed energy in the network. For managing energy consumption, two free space and multi-path models are applied to calculate the energy consumed by the receiver and transmitter. The total energy used in the network is the sum of the energy required by receivers and transmitters:

$$E_{Total}=\sum _{i=1}^N\left(E_{tx}^i+E_{rx}^i\right)$$

(3)

where $E_{tx}^i$ and $E_{rx}^i$ indicate the energy used for sending and receiving data by the IoT node i, respectively.

Suppose that the distance from the transmitter to receiver is equal to d, and the transmitter wants to transfer l bits to the receiver. In this case, the energy consumed by the transmitter node is expressed with regard to Equation (4):

$$E_{tx}\left(l,d\right)=\left\{\begin{array}{c}l\times E_{elec}+l\times {\epsilon }_{fs}\times d^2,d<d_0\\ l\times E_{elec}+l\times {\epsilon }_{mp}\times d^4,d\ge d_0\end{array}\right.$$

(4)

where $E_{elec}$ means the energy consumed by the electrical circuit of receiver/transmitter to receive/send each bit. ${ϵ}_{fs}$ indicates the signal amplifier coefficient in the free space and ${ϵ}_{mp}$ represents this coefficient in the multi-path space. $d_0$ reflects the threshold (border condition) for the data transfer model used by IoT nodes:

$$d_0=\sqrt{\frac{{ϵ}_{fs}}{{ϵ}_{mp}}}$$

(5)

Finally, the energy consumed by the receiver node for receiving l bits is calculated based on Equation (6):

$$E_{rx}\left(l\right)=l\times E_{elec}$$

(6)

4.3. Attack Model

IoT deals with security attacks due to wireless communication channels, and an attacker may launch various attacks, including wormhole, flooding, denial of service (DoS), black hole, and selective forwarding to disrupt the secure data transfer operation. The purpose of these attacks is to prevent the data transfer process, discharge the energy of IoT nodes, and disrupt the normal performance of the routing protocol. This article focuses on the black hole attack. In IoT, when the black hole node receives a route request message (RREQ), it quickly responds to this message and declares that it has the shortest route to the destination. After the fake route reply message (Fake-RREP) is received by the source node, an insecure path is formed on the network. In this mode, the black hole node acts as an intermediate node in this insecure path and eliminates all data packets. Figure 3 displays a black hole attack. In this attack, the attacker executes the following operations in the network:

• The black hole node does not send any route request message.
• The black hole node deletes all received data packets in the network.
• The black hole node responds to all RREQs to form fake routes on the network.
• The black hole node cancels all routing packets and route error packets (RERR).

5. The Proposed Routing Method

Here, the tree-cluster-based secure routing protocol using the dragonfly algorithm (CTSRD) is described for IoT networks in detail. CTSRD consists of three main phases:

• Distributed and lightweight trust mechanism (W-trust);
• Trust-based clustering process (T-clustering);
• Routing tree based on dragonfly algorithm (DA-tree);

5.1. Distributed and Lightweight Trust Mechanism (W-Trust)

In this section, the weighted trust mechanism (W-Trust) is presented. W-Trust is a lightweight and distributed mechanism that evaluates the trust level of IoT nodes based on their interactions when sending and receiving data packets. If W-Trust detects that an IoT node behaves maliciously, it reduces the direct trust related to this node with regard to a penalty factor to isolate this node and prevent its malicious activities in the network. Furthermore, if W-Trust detects that an IoT node has satisfactory activities in the network, it will improve the direct trust level of this node with regard to a reward factor to increase the participation of this node in the routing process. Therefore, W-Trust must calculate three parameters, namely direct trust, indirect trust, and total trust. In the following, these parameters are explained.

5.1.1. Direct Trust

The direct trust of the node i relative to the node j is displayed as $T_{ij}^{direct}$. It is the immediate trust produced by the node i for the node j. $T_{ij}^{direct}$ is obtained from the direct interaction between the two nodes over a time period such as $\left(t-1,t\right]$. To calculate $T_{ij}^{direct}$ at the interval $\left(t-1,t\right]$ using Equation (7), the node i calculates the packet sending rate and the packet receiving rate from/to the node j during this time interval.

$$T_{ij}^{direct}\left(t\right)=\lambda PS{R}_j\left(t\right)+\left(1-\lambda \right)PR{R}_j\left(t\right)$$

(7)

where $\lambda \in \left[0,1\right]$ is an adjustable weight coefficient. $PS{R}_j\left(t\right)$ and $PR{R}_j\left(t\right)$ are the packet sending rate and the packet receiving rate of the node j at the time interval $\left(t-1,t\right]$, respectively. They are obtained from Equations (8) and (9), respectively.

$$PS{R}_j\left(t\right)=\frac{M_j^{sent}\left(t\right)}{M_j^{all-sent}\left(t\right)}$$

(8)

so that $M_j^{sent}\left(t\right)$ demonstrates all packets sent from the node j to the node i at the interval $\left(t-1,t\right]$. Moreover, $M_j^{all-sent}\left(t\right)$ represents the total number of packets that must be sent to the node i at $\left(t-1,t\right]$.

$$PR{R}_j\left(t\right)=\frac{M_j^{received}\left(t\right)}{M_j^{all-received}\left(t\right)}$$

(9)

where $M_j^{received}\left(t\right)$ indicates all packets received by the node j at the interval $\left(t-1,t\right]$. Furthermore, $M_j^{all-received}\left(t\right)$ is the total number of packets that must be received from the node i at $\left(t-1,t\right]$.

Now, $T_{ij}^{direct}$ is standardized based on Equation (10).

$$T_{ij}^{standard}\left(t\right)=\frac{T_{ij}^{direct}\left(t\right)-{\mu }_{ij}}{{\sigma }_{ij}}$$

(10)

where ${\mu }_{ij}$ and ${\sigma }_{ij}$ are the average and standard deviation of $T_{ij}^{direct}\left(t\right)$, respectively. They are calculated according to Equations (10) and (11).

$${\mu }_{ij}=\frac{1}{M}\sum _{k=1}^M{T}_{ij}^{direct}\left(k\right)$$

(11)

$${\sigma }_{ij}=\sqrt{\frac{1}{M}\sum _{k=1}^M{\left(T_{ij}^{direct}\left(k\right)-{\mu }_{ij}\right)}^2}$$

(12)

In Equations (11) and (12), $M>0$ is a fixed number that indicates the number of direct trusts measured between the node i and the node j at a certain time.

According to Equation (10), if the direct trust calculated for the node j by the node i is less than ${\mu }_{ij}$ (i.e., $T_{ij}^{standard}\left(t\right)<0$), the node i recognizes this node as a malicious node and reduces the direct trust associated with this node based on a penalty factor to isolate this node and avoid its hostile activities on the network. In addition, if the direct trust calculated for the node j by the node i is higher than ${\mu }_{ij}$ (i.e., $T_{ij}^{standard}\left(t\right)\ge 0$), the node i recognizes this node as an honest node and increases its direct trust with regard to a reward factor to improve its participation in the routing process. This weight coefficient is calculated through Equation (13).

$$\mathsf{\Psi }=1-e^{-T_{ij}^{{}_{standard}}}$$

(13)

Next, the node i uses the technique of the window mean with exponentially weighted moving average (WMEWMA) to update $T_{ij}^{direct}$. This technique considers a window with the length w. This window is applied to save the last w values of $T_{ij}^{direct}$. This helps the node i to consider both the last and historical values of $T_{ij}^{direct}$ and have a better estimation of $T_{ij}^{direct}$. Accordingly, $T_{ij}^{direct}$ is updated by the node i according to Equation (14).

$$T_{ij}^{direct}\left(l\right)=\left(1-\beta \right)\frac{{\displaystyle \sum _{k=l-w}^{l-1}}{T}_{ij}^{direct}\left(k\right)}{w}+\beta T_{ij}^{direct}\left(t\right)$$

(14)

where $\beta$ is an adjustable parameter in $\left[0,1\right]$ and w is the window length.

Finally, the weighted direct trust of the node i relative to the node j is obtained through Equation (15).

$$T_{ij}^{Weighted-direct}=\mathsf{\Psi }{T}_{ij}^{direct}\left(l\right)$$

(15)

5.1.2. Indirect Trust

The indirect trust of the node i relative to the node j (i.e., $T_{ij}^{indirect}$) means the performance analysis of the node j by a group of recommender nodes. To calculate this parameter, recommender nodes must be determined accurately. In W-Trust, recommender nodes are a set of common neighbors of the nodes i and j, so that their weighted trust level is more than $T_{threshold}$. Suppose two nodes i and j have p common neighbors (i.e., $Nei=\left\{ne{i}_1,ne{i}_2,...,ne{i}_p\right\}$), and their trust level is higher $T_{threshold}$. In this case, the weighted indirect trust ($T_{ij}^{Weighted-indirect}$) is calculated based on Equation (16).

$$T_{ij}^{Weighted-indirect}\left(t\right)=\frac{1}{p}\sum _{r\in Nei}^p\left(T_{ir}^{Weighted-direct}·T_{rj}^{Weighted-direct}\right)$$

(16)

where $T_{ir}^{Weighted-direct}$ indicates the weighted direct trust of the node i relative to the node r. $T_{rj}^{Weighted-direct}$ represents the weighted direct trust of the node r relative to the node j. Furthermore, the node r is a recommender node with the trust value more than $T_{threshold}$.

5.1.3. Total Trust

It represents the sum of direct trust and indirect trust and is obtained from Equation (17).

$$T_{ij}^{total}=\alpha T_{ij}^{Weighted-direct}+\left(1-\alpha \right)T_{ij}^{Weighted-indirect}$$

(17)

where $\alpha \in \left[0,1\right]$ is a weight coefficient.

Algorithm 1 offers the pseudo-code related to the trust mechanism presented in CTSRD.

Algorithm 1 W-Trust mechanism

Input:  $n_i$, $n_j$, $n_r$: IoT nodes Output:  $T_{ij}^{total}$: Total trust between $n_i$ and $n_j$   Begin   1: ${\mathbf{n}}_{\mathbf{i}}$: Calculate the direct trust between $n_i$ and $n_j$ based on PSR and PRR using Equation (7); 2: ${\mathbf{n}}_{\mathbf{i}}$: Standardize $T_{ij}^{direct}$ using Equation (10); 3: ${\mathbf{n}}_{\mathbf{i}}$: Compute a weight coefficient based on $T_{ij}^{standard}$ using Equation (13); 4: ${\mathbf{n}}_{\mathbf{i}}$: Update $T_{ij}^{direct}$ using Equation (14); 5: if  $T_{ij}^{standard}\left(t\right)<0$  then 6:   ${\mathbf{n}}_{\mathbf{i}}$: Penalize $T_{ij}^{direct}$ based on Equation (15); 7: else if  $T_{ij}^{standard}\left(t\right)\ge 0$  then 8:   ${\mathbf{n}}_{\mathbf{i}}$: Reward $T_{ij}^{direct}$ based on Equation (15); 9: end if 10: ${\mathbf{n}}_{\mathbf{i}}$: Calculate $T_{ij}^{Weighted-indirect}$ using Equation (16); 11: ${\mathbf{n}}_{\mathbf{i}}$: Compute $T_{ij}^{total}$ using Equation (17);   End

5.2. Trust-Based Clustering Process (T-Clustering)

In this section, the trust-based clustering process (T-Clustering) is presented in the proposed method. In this process, the cluster head nodes (CHs) are only selected from the honest nodes whose trust level is greater than $T_{threshold}$. In general, T-Clustering includes several steps: selecting CHs, joining the cluster, leaving the cluster, and supporting the cluster.

• Selecting a CH node: In CTSRD, each IoT node periodically exchanges a beacon message with its neighbors. This message contains information about the location, remaining energy, and trust value of the corresponding node. According to this message, each IoT node holds a neighborhood table for recording the information obtained from its single-hop neighboring nodes. According to the information in this table, each node such as $n_i$ uses Equation (18) to calculate its chance ($S_i$) to be selected as CH. This chance depends on four parameters, including the centrality of the node, the remaining energy, the neighbor degree, and the distance to the base station.

  $$S_i=\frac{\left(\frac{E_i}{E_{max}}\right)\times \left(\frac{De{g}_i}{N}\right)}{\left(\frac{1}{N_i}{\displaystyle \sum _{n_j\in Nei}^{N_i}}d\left(n_i,n_j\right)\right)\times \left(\frac{d\left(n_i,BS\right)}{d_{max}}\right)}$$

  (18)

  where $E_i$ and $E_{max}$ are the remaining energy and the primary energy of $n_i$, respectively. Furthermore, $De{g}_i$ indicates the neighbor degree of $n_i$, which is obtained from the neighborhood table. N is the total number of all IoT nodes. $d\left(n_i,n_j\right)$ and $d\left(n_i,BS\right)$ represent the distance between $n_i$ and the neighboring node (such as $n_j$), and the distance between $n_i$ and BS, respectively. They are calculated based on Equations (19) and (20), respectively. $N_i$ is the number of neighbors of $n_i$ and is obtained from the neighborhood table. $Nei$ reflects the set of neighbors of $n_i$. Moreover, $d_{max}$ indicates the maximum distance between IoT nodes and BS. It is estimated according to the dimensions of the network. For example, if the dimensions are $p\times q$, then $d_{max}=\sqrt{p^2+q^2}$.

  $$d\left(n_i,n_j\right)=\sqrt{{\left(x_i-x_j\right)}^2+{\left(y_i-y_j\right)}^2}$$

  (19)

  $$d\left(n_i,BS\right)=\sqrt{{\left(x_i-x_{BS}\right)}^2+{\left(y_i-y_{BS}\right)}^2}$$

  (20)

  so that $\left(x_i,y_i\right)$, $\left(x_j,y_j\right)$, and $\left(x_{BS},y_{BS}\right)$ are the spatial coordinates of $n_i$, $n_j$, and BS, respectively. Then, each IoT node such as $n_i$ shares its chance ($S_i$) with other IoT nodes through the beacon messages. Finally, a node with the highest chance introduces itself as a node.
• Joining the cluster: After IoT nodes have received beacon messages from each other, they extract the chances of neighboring nodes from these messages. Then, each IoT node such as $n_i$ compares its chance ($S_i$) to the chances of other neighboring nodes. If $n_i$ has the highest chance compared to neighbors, it broadcasts a CH-candidate message to its neighbors to inform them of its status. Otherwise, if the chance of $n_i$ is less than other neighboring nodes, it waits for receiving CH-candidate messages from other neighboring nodes. Suppose that $n_i$ receives multiple CH-candidate messages from different neighboring nodes. In this case, $n_i$ is connected to the safest CH, which is a node with the highest trust level. Then, the CH transfers an ACK message to the cluster member node.
• Leaving the cluster: In IoT, the energy of cluster member nodes may end and these nodes die due to resource depletion. Therefore, it is necessary for CHs to be aware of the status of their members at any moment. To achieve this, CMs periodically send a beacon message to their CH to announce their membership to the cluster. If a specified time period ($T_{end}$) is expired, and the CH does not receive any beacon packet from its cluster member node, it deletes the identification of this node from its cluster member list to cancel its membership to the cluster.
• Supporting the node: It is a very important step in any clustering algorithm. If the trust level corresponding to the CH node decreases, or its energy is lower than an energy threshold, it is necessary to replace this CH. In CTSRD, when the cluster is formed, the CH node records the cluster members in a list and saves their chances and trust levels. Then, CH chooses a backup CH node, which is a node with the maximum chance from CMs with the highest trust level. When the CH node is exposed to failure, the backup CH is responsible for playing the role of CH.

Algorithm 2 shows the pseudo-code related to T-Clustering in CTSRD.

Algorithm 2 T-Clustering

Input:  $n_i$: IoT nodes ($i=1,...,N$)     $Timer=0$ Output:  Clustered network   Begin   1: if  $Timer=Beaconperiod$then 2:   for $i=1$ to N do 3:    ${\mathbf{n}}_{\mathbf{i}}$: Broadcast a beacon message in the network; 4:    ${\mathbf{n}}_{\mathbf{i}}$: Update a neighboring table in the network; 5:    $Timer=0$; 6:   end for 7: end if 8: ${\mathbf{n}}_{\mathbf{i}}$: Calculate the CH chance ($S_i$) using Equation (18); 9: ${\mathbf{n}}_{\mathbf{i}}$: Share the CH chance ($S_i$) through a beacon message with its neighboring nodes; 10: if $S_i$ is higher than the CH chance of the neighboring nodes then 11:   ${\mathbf{n}}_{\mathbf{i}}$: Broadcast a CH-candidate message in the network; 12: else 13:   ${\mathbf{n}}_{\mathbf{i}}$: Wait to receive the CH-candidate messages from neighbors; 14:   if $n_i$ receives various CH-candidate messages from different neighbors then 15:    ${\mathbf{n}}_{\mathbf{i}}$: Join the CH with highest trust; 16:    CH: Select a trust node with highest CH chance from its member list as the backup CH; 17:   else 18:    ${\mathbf{n}}_{\mathbf{i}}$: Join the CH; 19:    CH: Select a trust node with highest CH chance from its member list as the backup CH; 20:   end if 21: end if 22: if CH does not receive the beacon message from a cluster member node after $T_{end}$ then 23:   CH: Revoke this cluster member node from its member list; 24: end if 25: if  $T_{CH}<T_{threshold}$  or  $E_{CH}<E_{threshold}$then 26:   CH: Replace the backup CH as the new CH; 27: end if 28: $Timer=Timer+1$; 29: go to Line 1;   End

5.3. Routing Tree Based on Dragonfly Algorithm (DA-Tree)

CTSRD creates a binary routing tree based on the dragonfly algorithm (DA-Tree) between CHs. The dragonfly algorithm must discover the best binary routing tree. Each CH transfers data packets to its parent through DA-Tree, so that these packets finally reach the base station. In this process, the task of BS is to run the DA-Tree algorithm to specify the positions of CHs in DA-Tree. In this issue, each dragonfly is a binary routing tree between CHs (i.e., a response to this issue). The routing tree creation is dependent on four parameters: the number of hops from CH to the base station, the remaining energy, the number of cluster members, and the trust level. The DA-Tree creation process involves five stages: the formation of the primary population, the DA-based tree creation, the tree evaluation, the stop condition, and the update of dragonflies. In the DA-Tree algorithm, we suppose that the BS knows the information about CHs, for example, the hop count between them and BS, their remaining energy, the number of their cluster members, and their trust level.

• Primary population formation: This step initializes each dragonfly using a random manner. Each dragonfly is an array whose number of elements indicates the number of CHs, and each element corresponds to a CH in the routing tree. The purpose of the dragonfly algorithm is to prioritize CHs on the network and place a CH with a higher priority at the upper level of the routing tree. Note that in each dragonfly, each element specifies the priority of the corresponding CH in the network.
• DA-based routing tree creation: This step describes how to create DA-Tree based on dragonflies. DA-Tree follows four rules.

  –

  Rule 1: The root of the tree is the base station.

  –

  Rule 2: According to the dragonfly, the CH with the maximum priority is the left child of BS, and the CH with the second priority is placed as the right child of the base station.

  –

  Rule 3: At each level of this binary routing tree, the leftmost CH must first determine its children. In this case, it first specifies its left child and then the right child in DA-Tree. The left child and the right child are two CHs, which have the highest and second priorities, respectively, and have not been chosen so far.

  –

  Rule 4: If two CH have a similar priority in a dragonfly, the CH with a higher trust level has a higher priority.

• Tree evaluation: This step presents a fitness function to evaluate the formed routing trees. This function comprises four scales:
  1. Number of hops to BS
  This scale is used in the fitness function to place CHs close to BS at the upper tree levels because these nodes consume less energy to send data to BS.
  2. Remaining energy
  This parameter is considered in the fitness function to place high-energy CHs at the upper tree levels because the nodes placed at upper levels have more tasks and require a lot of energy. They must send data related to their cluster member nodes as well as data packets received from other CHs in their sub-tree to the BS.
  3. Number of cluster members
  This parameter is used in the fitness function to place CHs, which connect to the small number of cluster members at upper tree levels. If there is a cluster head node that connects to many CMs, it needs a lot of energy to receive/send data packets within the cluster. Thus, it must be placed at the downer tree levels to reduce the communication overhead due to inter-cluster connections. This improves energy consumption in the network.
  4. Trust level
  This scale is used in the fitness function to place the safer CHs at upper tree levels. CHs at upper tree levels have more tasks in terms of inter-cluster communications. As a result, these nodes should be safer because, if a malicious node attacks these CHs, it can cause more damage to the network performance.
  Finally, this fitness function is calculated based on Equation (21).

  $$F=\sum _{D=1}^{⌊log{n}_{CH}⌋}\frac{1}{D}\left(\sum _{i=1}^c\frac{\left(\frac{E_i}{E_{max}}\right)\times \left(\frac{T_i^{total}}{T_{max}}\right)}{\left(\frac{ho{p}_{count}\left(n_i,BS\right)}{N-1}\right)\times \left(\frac{n{c}_i}{n_{max}}\right)}\right)$$

  (21)

  where D indicates the tree depth, $n_{CH}$ represents the number of CHs, c expresses the number of CHs in the current tree depth, $ho{p}_{count}\left(n_i,BS\right)$ indicates hop count from the $C{H}_i$ to BS, N is the number of nodes in the network, $E_i$ represents the remaining energy of $C{H}_i$, $n{c}_i$ is the number of CMs in the cluster i, $n_{max}$ represents the maximum number of CMs in a cluster. It is equal to $⌈\frac{2N}{n_{CH}}⌉$.
• Stop condition: This step specifies the stop condition of the DA-Tree algorithm. When it is met, the DA-Tree algorithm ends, and the best response is considered its output. In the DA-Tree, the stop condition is 300 iterations for ending this algorithm. Upon the completion of the algorithm, the BS sends a message to CHs to inform them of their positions in this routing tree.
• Dragonflies update: At this stage, the values of dragonflies are refreshed in accordance with Equations (1) and (2) related to the DA algorithm.

Algorithm 3 expresses the pseudo-code of the DA-Tree algorithm.

Algorithm 3 DA-Tree

Input:  $n_i$: IoT nodes ($i=1,...,N$) Output:  DA-Tree   Begin   1: BS: Initialize DA parameters; 2: BS: Form the initial population; 3: for $i=1$ to 300 do 4:    BS: Establish binary routing trees between CHs based on dragonflies; 5:    BS: Evaluate routing trees based on Equation (21); 6:    BS: Determine the best and worst responses in the population; 7:    BS: Update the position of dragonflies using the Equations (1) and (2) of the dragonfly algorithm; 8: end for 9: BS: Return the routing tree with highest fitness;   End

6. Simulation and Evaluation of Results

CTSRD has been implemented using the network simulator version 2 (NS2), and various tests are performed to analyze and compare its performance with the results obtained from EEMSR [29] and E-BEENISH [30]. The reasons for selecting EEMSR and E-BEENISH are:

• EEMSR, like CTSRD, focuses on network security and energy efficiency simultaneously while E-BEENISH only focuses on energy efficiency.
• Both EEMSR and E-BEENISH use an efficient clustering method, as in our scheme.
• EEMSR presents a GA-based routing method for creating paths between CHs while our scheme uses DA for creating a routing tree between CHs.

Thus, the comparison of our scheme with EEMSR and E-BEENISH presents valuable results. Note that EEMSR and E-BEENISH are also simulated in NS2. The evaluation operation of these results is based on the simulation parameters defined in

Table 3. Simulation parameters.

Parameter	Value
Simulator	NS2
Network environment	$100\times 100$m${}^2$
BS location	$\left(50,100\right)$
Number of IoT nodes	100
Types of IoT nodes	Four types
Energy of IoT nodes	$E_1=2J$, $E_2=2E_1$, $E_3=2.5E_1$, $E_4=3E_1$
Connection radius of IoT nodes	$20$ m
Trust threshold ($T_{threshold}$)	$0.5$
Packet size	$500$ Byte
Maximum transmissions	$100$ packet/round
Energy consumed by the electrical circuit of receiver/transmitter ($E_{elec}$)	$50$ nJ/bit
Signal amplifier coefficient in the free space (${ϵ}_{fs}$)	10 pJ/bit/${\mathrm{m}}^2$
Signal amplifier coefficient in the multi-path space (${ϵ}_{mp}$)	0.0013 pJ/bit/m${}^4$
Population size	80
Stop condition	$300$ iterations

. According to this table, 100 IoT nodes are randomly distributed on the network, and the size of the simulation environment is $100\times 100$m${}^2$. The connection radius of IoT nodes is 20 m. IoT nodes are heterogeneous and have different energy levels. In this paper, it is assumed that there are four types of IoT nodes whose energy levels are $E_1=2J$, $E_2=2E_1$, $E_3=2.5E_1$, and $E_4=3E_1$, so that the percentages of type 1, type 2, type 3, and type 4 are 50%, 35%, 12%, and 3%, respectively. The size of the packets is 500 bytes, and 100 transmissions are performed at each round. Note that the simulation results are presented with regard to a number of rounds. Thus, the simulation process is executed one time.

6.1. Trust Evaluation

Figure 4 shows the trust level of IoT nodes (including honest and malicious nodes) with regard to the number of rounds. The experiment assumes that 10% of the IoT nodes are malicious, and the trust threshold is equal to 0.5. According to this figure, when interactions between IoT nodes increase over time, the trust level of honest nodes gradually approaches one. However, the trust level of malicious nodes decreases and makes zero. The experiment shows that, when increasing interactions between IoT nodes, CTSRD can detect the abnormal behavior of malicious nodes and isolate them in the network.

6.2. Network Lifetime

Figure 5 presents an evaluation of network lifetime in various routing approaches. As shown in this figure, CTSRD has the longest network lifetime compared to others. On average, it reduces the number of dead nodes by 20.92% and 61.57% compared to EEMSR and E-BEENISH, respectively. In this figure, CTSRD has the longest first node die (FND) time, and EEMSR has the second rank. However, the performance of E-BEENISH is not satisfactory. The most important reason is that CTSRD and EEMSR have taken into account energy efficiency and security simultaneously, but E-BEENISH is just an energy-efficient method that ignores the security of IoT nodes. As a result, malicious nodes have a negative effect on this method and reduce its lifetime. On the other hand, CTSRD and EEMSR use a multi-hop routing technique between CHs. This maintains and balances energy consumption between network nodes. However, in E-BEENISH, each CH sends their data directly to BS. This does not balance the consumed energy of network nodes and reduces network lifetime. Another reason is that CTSRD considers several parameters, including trust, energy, intra-cluster traffic, distance, and hop count when designing a fitness function to form an energy-efficient and secure routing tree (DA-Tree) between CHs in the network. However, EEMSR has only taken into account the square of the distance between CHs for designing the fitness function. As a result, the path formed between CHs in EEMSR may not be energy-efficient. The effect of this issue is clear on network lifetime in CTSRD and EEMSR.

In another experiment, the location of BS is changed to evaluate the adaptability of different methods. A routing method is adaptable if the position of BS changes without affecting the network performance. In Figure 6, the location of BS is $\left(0,0\right)$. Furthermore, in Figure 7, the location of BS is $\left(50,50\right)$. When the location of the base station is $\left(0,0\right)$, CTSRD reduces the number of dead nodes by 26.38% and 77.65% compared to EEMSR and E-BEENNISH, respectively. In addition, when the location of the base station is $\left(50,50\right)$, CTSRD lowers the number of dead nodes by 35.36% and 74.78% compared with EEMSR and E-BEENISH, respectively. These experiments indicate that CTSRD and EEMSR are adaptable but E-BEENISH is not adaptable.

6.3. Remaining Energy

Figure 8 represents the remaining energy of IoT nodes in different methods. Based on this figure, CTSRD consumed the least energy in comparison with other schemes. On average, it stores more energy by 16.65% and 35.35% compared to EEMSR and E-BEENISH, respectively. The reason for this issue was stated when examining the network lifetime. Note that E-BEENISH has the worst performance because it focuses only on the energy parameter when choosing CHs and ignores security. Moreover, it does not consider multi-hop paths between CHs. This increases the energy consumption in some IoT nodes. EEMSR has resolved the problems mentioned in E-BEENISH, however, it uses the genetic algorithm in the routing process and may fall into the local optimum. Furthermore, the designed fitness function only focuses on the distance between CHs. That is not enough. In CTSRD, the routing algorithm between IoT nodes is performed using a dragonfly algorithm-based routing tree. When designing this fitness function, intra-cluster traffic and energy are considered to balance the energy consumption between IoT nodes.

Another experiment expresses the balanced distribution of energy consumption between IoT nodes by evaluating the standard deviation of their consumed energy in Figure 9. If the energy consumed in the IoT network is uniformly distributed between the IoT nodes, the standard deviation is close to zero. However, if the energy consumed by IoT nodes is unbalanced, the standard deviation increases and approaches one. As shown in this figure, CTSRD has a more successful performance than EEMSR in terms of energy consumption (approximately 16.11%) and has a very good performance (almost three times that of E-BEENISH).

6.4. Packet Delivery Rate (PDR)

Figure 10 compares PDR in various approaches. This test shows the successful performance of CTSRD. However, it has a lower PDR than EEMSR (approximately 0.4%) because EEMSR uses the beta distribution to build a trust system, which is more powerful than the W-Trust mechanism presented in CTSRD. Furthermore, E-BEENISH has the weakest performance in terms of packet delivery rate (approximately 8.03% weaker than CTSRD) because it has not designed any security mechanism. As a result, attackers can increase packet loss by disrupting the intra-cluster and inter-cluster connections. To assess the security in IoT, the number of packets received by BS is evaluated in another test shown in Figure 11. If the number of packets received by BS is small, the security of this method is weaker because hostile nodes remove some data packets. According to this figure, EEMSR has the highest number of packets received by BS, and in the proposed method, BS has received approximately 3.15% less packets than EEMSR. Moreover, CTSRD is more successful than E-BEENISH by approximately 14.56%. Another point in this figure is that increasing interactions between IoT nodes over time specifies their trust level more accurately. This allows all routing methods to increase the number of packets received by the BS in the higher rounds.

7. Conclusions

In this paper, the tree-cluster-based secure and energy-efficient routing protocol based on the dragonfly algorithm (CTSRD) was proposed for IoT networks in smart agriculture. The proposed method consists of three main steps: weighted trust mechanism (W-Trust), trust-based clustering process (T-Clustering), and dragonfly algorithm-based routing tree (DA-Tree). W-Trust is a lightweight and distributed mechanism that evaluates the trust level of IoT nodes and assigns a penalty/reward coefficient to them. T-Clustering is a trust-based clustering method that chooses nodes based on centrality, energy, neighbor degree, and distance to the BS. When designing DA-Tree, a new fitness function is provided based on the hop count to the base station, residual energy, intra-cluster traffic, and the trust level. Finally, CTSRD was compared with the NS2 simulator, and its results were compared with E-BEENISH and EEMSR. This comparison shows that CTSRD is an energy-efficient method and distributes the energy consumed in the network in a balanced manner. This has reduced the number of dead nodes by 20.92% and 61.57% compared to EEMSR and E-BEENISH, respectively. Furthermore, CTSRD can increase the stored energy by 16.65% and 35.31% compared to EEMSR and E-BEENISH, respectively. CTSRD has improved the packet delivery rate by approximately 8.03% compared to E-BEENISH. However, it has a weaker PDR than EEMSR (approximately 0.4%). In future research directions, we will perform more detailed comparisons to better show the strengths and weaknesses of our scheme. Furthermore, we will focus on the applications of deep learning and other machine learning (ML) techniques for improving communications in IoT in future research directions.