Honesty-Based Social Technique to Enhance Cooperation in Social Internet of Things

Abstract

The Social Internet of Things (SIoT) can be seen as integrating the social networking concept into the Internet of Things (IoT). Such networks enable different devices to form social relationships among themselves depending on pre-programmed rules and the preferences of their owners. When SIoT devices encounter one another on the spur of the moment, they seek out each other’s assistance. The connectivity of such smart objects reveals new horizons for innovative applications empowering objects with cognizance. This enables smart objects to socialize with each other based on mutual interests and social aspects. Trust building in social networks has provided a new perspective for providing services to providers based on relationships like human ones. However, the connected IoT nodes in the community may show a lack of interest in forwarding packets in the network communication to save their resources, such as battery, energy, bandwidth, and memory. This act of selfishness can highly degrade the performance of the network. To enhance the cooperation among nodes in the network a novel technique is needed to improve the performance of the network. In this article, we address the issue of the selfishness of the nodes through the formation of a credible community based on honesty. A social process is used to form communities and select heads in these communities. The selected community heads having social attributes prove effective in determining the social behavior of the nodes as honest or selfish. Unlike other schemes, the dishonest nodes are isolated in a separate domain, and they are given several chances to rejoin the community after increasing their honesty levels. The proposed social technique was simulated using MATLAB and compared with existing schemes to show its effectiveness. Our proposed technique outperforms the existing techniques in terms of throughput, overhead, packet delivery ratio (PDR), and packet-delivery latency.

1. Introduction

The Internet of Things (IoT) is the connection of physical objects that feature IP addresses for the Internet’s connectivity and the communications between them. The IoT has different technologies working in the cycle, rather than being based on a single piece of technology [1]. IoT is a network with intelligence to connect all things to the Internet to share information using some protocols. The things on the Internet sense, send data, and provide intelligent solutions to the underlying network [2]. IoT devices are not limited to traditional devices such as laptops, personal computers, mobile phones, and tablets. There is a diverse range of devices that use embedded technologies to communicate and interact with the environment throughout the Internet. The main technologies include sensors and actuators that interact with the physical environment. Actuators are intelligent enough to store and share data. Many sensor attributes, such as memory size, battery life, and computational power, restrict data processing. The processing is performed by the network and sometimes processed by the central remote servers. Some examples include connected security systems, cars, electronic home appliances, and various devices in the commercial environment and industry [3]. IoT has taken the world by storm, as millions of smart devices are deployed daily in the home, business, office, and industries. These greatly influence the cutting of costs, the reduction of energy consumption, the improvement of health care, and the creating of smart cities that improve human life. Thus, we need a better understanding of how devices are connected in smart homes [4]. The IoT industry is rapidly growing, being predicted to increase from 892 million USD now to 4 trillion USD by 2025 [5].

A novel mode of communication is the Social Internet of Things (SIoT), where the connected nodes in the IoT have social attributes [6]. The structure of the SIoT is modeled to help navigate the nodes’ discovery, as we do in social networks. The establishment of trust through honesty among nodes can be addressed in SIoT to show the degree of interactions [7]. The ability of these objects to socialize with each other intelligently results in a social network. These objects manage such communities intelligently without direct communication with humans [8]. The data in the different applications are at risk of being leaked out. Therefore, trust must be established among the connected nodes to keep the data reliable and private. Trust is key in keeping the data personal, reliable, and confidential [9]. More trusted nodes in a network means a more reliable system. Various parameters and the nodes’ social behavior contribute to the nodes’ trust in the network. In [10], researchers proposed a machine learning-based approach to compute trust in SIoT networks. This scheme works on the computation of direct and indirect trust to isolate trustworthy and untrustworthy nodes in the network.

The role of reputation is widely justified in the SIoT environment, where the nodes are vulnerable to risks due to incomplete information. The reputations of nodes are used in the network to predict their behavior, based on experience and accumulated information [11]. In [12,13,14,15,16,17,18,19], various schemes for increasing the trust values of nodes and to detect the misbehaving nodes in the SIoT networks to enhance their performance levels were discussed.

In [20], the Copy-Adjustable Incentive Scheme (CAIS) using a virtual credit-based mechanism to incentivize the selfish nodes to forward messages to their neighboring nodes was presented. Social and non-social credits are given to the selfish nodes both inside and outside of the community. The DSL-STM [21] was proposed with three multilevel trust schemes. The proposed mechanism is scalable and dynamic in practice for SIOT networks. The DSL-STM uses user trust dimensions, device trust dimensions, and service trust dimensions as metrics to show the behavior of nodes in the SIoT environment. These three metrics are combined through a machine learning-based method to detect the behavior of nodes in the SIOT.

Various trust-based techniques have been used to detect and omit the selfish behavior of nodes in networks. Unlike current incentive and reputation-based techniques, our proposed social technique has different approaches to (i) credible community creation, (ii) selfish nodes after detection, and (iii) selection of heads. Other techniques lack the creation of a credible community. Nodes can be assessed by their honesty levels, and a credible community can be formed. In other techniques, the nodes with selfish behavior are warned and then expelled from the community after showing repeated selfish behavior. In our social technique, the nodes with selfish behavior are isolated in the selfish domain. Each selfish node is given a chance to rejoin the community by increasing its honesty level. The selection criteria of heads involve the node’s seniority level, which is not considered in other techniques. A senior node has better knowledge of the network, having spent a long time in the network to make decisions about nodes’ performances. In the proposed technique, trust parameters and social behavior are used to detect the selfish nodes in the network and stimulate them for better performance. A credible community is formulated based on the honesty levels of the nodes. A social technique is then used to select the heads of the community for the incentivization and punishment of nodes in the community. Detection of the selfish behavior of nodes is the major problem in SIoT networks. This issue has been addressed by many researchers, and our motivations for this study were as follows:

• Detection of selfish nodes in the network.
• Increasing the number of honest nodes in the network to enhance the performance of the network.
• Devising a social technique for the heads’ selection to overcome the complexity in some contemporary schemes for the selection of heads.
• Separating the selfish nodes from honest nodes for the better utilization of network resources.

The following are the key benefits of the proposed scheme:

• Selfish nodes are stimulated for cooperation easily.
• Network performance is optimized.
• Our technique realizes the social aspects of the nodes in the SIoT.
• Our technique effectively handles the detection of the selfish behavior of the nodes.
• The isolation of selfish nodes helps with improving their social behavior.

The primary contributions of our proposed scheme are:

• An honesty-based, credible community is established.
• The seniority of the node is considered for head selection.
• Isolation of selfish nodes from the community to improve the network’s performance.

The following are the objectives of the proposed technique:

• Establishing a credible community based on honesty attributes.
• Enabling reliable communication among the nodes in the network to increase the number of honest nodes in the network for better utilization of the resources.
• Proposing a mechanism to detect dishonest and selfish nodes in the network.
• Separating the selfish nodes in a selfish domain.
• Providing a chance to the selfish and dishonest nodes to participate in the network and hence increase the network’s performance.

The rest of the paper is organized as: The literature review is given in Section 2. The proposed model is defined and explained in Section 3. The procedures for the isolation of nodes and punishment are explained in Section 4. Section 5 discusses the monitoring system. The simulation results, comparisons, and performance analysis are given in Section 6. Finally, Section 7 concludes the proposed work and discusses the future directions.

2. Literature Review

IoT is the eminent communication model for computing devices’ dynamic connectivity with different devices. The main technologies of the IoT domain are machine-to-machine communication, data-aware routing, and radio-frequency identification (RFID). Some seamlessly connected devices are smartwatches, sensors in smart homes for locking and unlocking, smart cities, smart vehicles, and smart forensics systems [22]. The IoT can also provide help in the current COVID-19 pandemic situation. The IoT can be used in smart healthcare systems for properly monitoring COVID patients by connecting various interconnected networks. This could greatly reduce healthcare costs and improve the treatment of COVID-19 patients. Applications such as ArogyaSetu and Close Contact are employed using IoT tactics to effectively trace COVID-19 patients and suspects [23].

Lack of cooperation among the connected nodes in the network is a challenge to forwarding data. Trust management is substantial in IoT, enabling networks to transfer reliable data to increase nodes’ privacy [24]. A multistep method has been proposed to detect selfish nodes in the network having three steps: (i) establishing a cluster, (ii) using multi-person game theory to send data to a node’s neighbor, and (iii) detection of selfish nodes by the reputations of the nodes [25]. In [26], a novel cumulative trust-based technique (CTBET) was proposed, based on the novel idea of cumulative trust in IoT-based networks. It calculates direct and indirect trust among the connected nodes in the network to improve the network’s security and privacy. This leads to trustworthy data transmission and identifies the selfish nodes by updating the node routing table. A distributed trust management technique investigates the node’s behavior and sends its trust value to the network. The technique is used to detect the nodes’ behavior based on the trust weight recommendations as selfish or honest [27]. In [28], a social technique called Social Characteristics-based Distributed Routing Algorithm (SCDRA) was presented, which uses the social features of the nodes, such as selecting friends and a community, to forward the data in the network efficiently. The nodes with strong friendships in the network have higher durations of communications, and data are forwarded successfully. Amin et al. [29] explain nearly all the aspects of SIoT in detail and integrates it conceptually with modern technologies such as big data, cloud computation, and other social networks. It further proposed six key aspects of SIoT: the discovery of services, navigability of objects, architecture, plate forms and tools used, relationships, and management of the trust. Nobahary et al. [30] used genetic algorithms and learning automation to detect malicious nodes in a route. The first clustering algorithm was used to set up clusters and routes. The nodes in the network worked collectively to forward data to the destination nodes. Each node’s performance was monitored by its neighbors, and the learning automation system detected the selfish nodes in the network. DASH avoids contact with selfish nodes, rather than isolating them in the network, in a novel approach to dealing with selfish nodes. The nodes with social behavior are avoided unless they start cooperating again. Thus, the selfish nodes are allowed to change their behavior to improve the network’s performance [31].

The Amin et al. [32] have proposed a community detection mechanism for the identification of network communities. They used the social influence of the central node on its neighbors to detect network communities. Local and global information play important roles in the detection mechanism. The proposed scheme Friendliness Based Trustworthy Relationship Management (F-TRM) [33] utilizes the honesty of the devices in the SIoT-based network. As humans make friends, the SIoT network devices also make friends to share their data and services. A node in the F-TRM scheme selects the best nodes which can provide services to other nodes in the network, and this updated feedback is sent to all the nodes in the SIoT network.

The node’s active participation improves the network’s performance in the network’s activities. The heads of the community are elected based on honesty parameters such as the centrality of nodes, nodes interactions, and node interest in the community. The elected heads provide incentives to the honest nodes and punish the nodes with selfish behavior in the community [34]. The authors of [35] proposed a watchdog system for detecting malicious nodes in the network and devised a mechanism to reduce the number of selfish nodes in the network to enhance its performance. The watchdog system’s operations are based on cooperatively exchanging the reputation scores of nodes. A hybrid approach was proposed in [36] to stimulate the nodes in the network to cooperate and reduce the number of selfish nodes in the network for better performance. The proposed model has a monitoring system to monitor the behavior of the nodes and an incentive module that stimulates the nodes for cooperation by providing incentives in the form of reputations.

A Q-learning technique combined with a multi-copy routing algorithm was used to calculate the credit value of each node to determine its suitability to deliver a message. To ease the congestion in the network, the nodes deleted already exchanged messages when meeting each other [37]. In [38] a social election technique was used to elect the heads and omit the selfishness in the network by assigning cooperation values as incentives. With the emergence of 5G/B5G, the IoT is transforming into the integrated Internet of the future. With the advancements in the intelligent transportation system, smart vehicles, and smart parking, the innovative technologies for the IoV have emerged to make data communication possible between vehicles and their environment. Such networks aim to ease traffic congestion, help reduce road accidents, and share other information for better utilization of vehicles [39]. In [40], the author discussed the social aspect of the SIoV. A vehicle in the network starts socializing when it meets other entities and shares common information such as traffic information, weather, road congestion, road safety, and car parking. SIoV systems are initiated from the manufacturing site by enabling the vehicle with sensors for different social operations. In SIoV, the vehicle maintains a social relationship list of other vehicles through on-board units (OBUs) to communicate with owners and other vehicles.

SOCIABLE is a novel vigorous system to disseminate data in an urban environment having an SIoV network. It selects a relay vehicle based on common community interests and similar social behavior of the vehicle. The architecture of SOCIABLE has community recognition and social influence components. Community recognition systems select the vehicles of the same community to create community knowledge and social influence component to calculate the importance of vehicles in the current community [41]. The environment surrounding the vehicle is not credible and not trustworthy. Smart contracts, physical unclonable functions (PUF), and certificates are used in a blockchain protocol to establish trust among the vehicles in IoV [42]. TACASHI has proposed a trust-aware social communication architecture for inter and in-vehicle structures in the SioV. The driver’s honesty is considered through online social networks, and historical mobility patterns of the vehicles are used to develop trust and path prediction [43]. An evolutionary game theory technique is used in [44] to evaluate reputation management. The system assigns specific reputation values to the network’s vehicles. If the reputation value of a vehicle drops to zero, it is marked as dishonest and removed from the network. For the reputation value of a traffic event, the initial reputation value of the traffic event is submitted to its vehicle, and if the value of the message drops to zero, the messages are removed from the broadcasting. An incentive punishment scheme (IPS) is a democratic election process to elect heads in the community to detect and punish the selfish nodes in the community. A mathematical model is used in the election process alongside monitoring of the nodes’ performances in the network. Nodes with cooperative behavior receive incentives in the form of reputation, and nodes with repeated selfish behavior are punished [45]. Social selfishness-aware routing (SSAR) is used in delay-tolerant networks (DTNs), where it considers each node’s willingness and contact opportunity to forward data to its fellow nodes [46]. The efficient monitoring system (EMS) is a social technique to detect cooperative and non-cooperative nodes in VDTN based on their cooperative behavior [47].

The proposed scheme is compared with some contemporary schemes in

Table 1. Relevant literature.

S. No.	Paper	Contributions	Limitations
1	Lai et al. [10]	Computes trust among the nodes in SIOT using a machine-learning approach Uses direct and indirect trust parameters Final trust is calculated using machine learning	The previous history is not considered in the trust calculation
2	Mohammadi et al. [14]	A generic model for exchanging services and resources in SIoT-based networks. Intelligent friend selection method. Use of social attributes topology, Communication willingness and Other nodes characteristics	The mobility of the nodes is an issue.
3	Jafarian et al. [17]	Considers the discriminatory behavior of the object to detect the behavior of the node in the network. Uses data mining techniques and the KNN algorithm to extract the meaning of the social attrib utes of the node. Social similarity service, the remaining energy and service importance are considered social attributes.	The node’s selfish behavior is only detected no action is taken to stimulate the nodes. No punishments for the selfish nodes.
4	Abdelghani et al. [21]	Multilevel trust model. It is a machine-based method. Three social attributes are used. User trust dimension Device trust dimension Service trust dimension	Can prove costly in a large network.
5	Nobahary et al. [25]	A multistep method is proposed to detect selfish nodes in the network having three Steps. Formation of cluster Multi-person game theory to send data to its neighbors. Detection of selfish nodes by the reputations of the node.	No punishment for the selfish nodes. No incentives for the selfish nodes to stimulate them for active participation.
6	Amin et al. [32]	Identification of network communities. Local and global information is used to detect the influential node in the community. Parameters-free scheme and no previous information are needed for community detection. Can be used in business applications to recommend friends.	Detects only network community. Do not detect the selfish nodes in the network.
7	Rajendran et al. [33]	Honesty-based mechanism to select friends. Uses an updated friendship directory. Privacy protection paradigm. Uses MIT and ARAS datasets to select friends in the network.	Security is a challenge when a new node is added to the community.
8	Rehman et al. [34]	Honesty-based democratic scheme Election-based scheme. Nodes are punished after repeated selfish behavior.	No isolation of selfish nodes. No credible community is created. Election process is overhead.
9	Dias et al. [35]	Watchdog system to detect selfish nodes Cooperative exchange of node’s reputation for selfish behavior of node.	Detects only selfish nodes. No incentives for the selfish nodes.
10	Rehman et al. [38]	Election based scheme Election of heads Cluster head Incentive head Monitoring head Incentives in the form of reputations and punishment of selfish nodes	Election process is overhead.
11	Talbi et al. [40]	Detection of untrusted behavior of nodes based on interest preferences. Uses both direct and indirect trust to calculate the behavior of the node. Grouped trustworthy and untrustworthy nodes separately.	The selfish behavior of the nodes is not identified.

.

The SIoT makes the objects smarter and incorporates social behavior in them. SIoT is a new concept, and little research has been performed in the field. One of the challenging tasks in the SIoT is to maintain reliable communications in the network. Any node in the network has to forward the data to its neighboring node to enable reliable communication. However, some nodes may not forward the data to their neighboring nodes to save their resources (battery, energy, bandwidth, etc.). Such nodes are selfish nodes and can degrade the network’s performance. As the social network grows, the number of selfish nodes also increases, affecting the network’s performance.

Any node which forwards the data to its neighbor node is termed an honest node and gives honest recommendations. Researchers use many techniques and schemes to detect and omit the node’s selfishness to improve the network’s performance. Still, a novel technique is required to detect selfish behavior and dishonest node in the network. The key considerations in the proposed mechanism are given in

Table 2. Key considerations.

Key Considerations	Current Literature	Our Proposed Work
Honesty	Honesty is considered an attribute of the election process	Honesty is considered a personal attribute to judge the behavior of a node.
Credible community	There is no consideration of credible community	A credible community is created based on the honesty level of the node
Head Selection	The heads are selected based on the reputation of the node in the community.	A novel technique is adopted to select the heads of the community where the seniority of nodes is considered.
Isolation of selfish nodes	Nodes with selfish behavior are punished.	The selfish nodes are isolated in a separate domain, and further chance is given to increase their honesty.
Node Stimulation	Normally the incentive and credit-based mechanisms block the selfish nodes immediately.	Nodes with selfish behavior are given warnings before expelling them from the community

.

3. Proposed Model

In our proposed model, we have a community comprised of many different nodes. The nodes in the community are socially bonded to form a social network, just like a human community where the people with the most resources are termed credible. Nodes in the community have strong social ties and cooperate with one another. The main community has all the nodes in it having some social status. The proposed scheme has three sections: (i) the selection of a credible community from the main community, (ii) the selection of heads from the credible community, and (iii) the section of a decision module, which declares the nodes as honest or selfish.

In the first phase of our proposed model, credible nodes are selected from the main community. This new community will be called a credible community having all the credible nodes. Credible nodes are all those nodes with a certain level of community reputation. The node’s reputation will be calculated through the honesty level of the node. After the formulation of a credible community, in the second selection phase, a social process is adopted to select two heads from the credible community having reputation criteria related to seniority, cooperative behavior, and energy level. The node with the highest weight of reputation criteria is selected as the selected community head, SCH, and the node with the second highest weight of reputation is selected as the selected monitoring head, SMH. The selected heads will be assigned responsibilities to stimulate the nodes in the network and omit the selfish behavior of the nodes in the network. The role of the SCH will be to stimulate the selfish nodes for participation in the network and can punish the selfish node reported by the SMH. The SMH will monitor the behavior of nodes in the community. If the node is selfish, it will be reported to the SCH to take some action. The SCH will isolate the selfish nodes in a separate domain, and no communication will be made with them. If the selfish node shows repeated selfish behavior, the SCH can expel it from the community—a severe punishment.

Table 3. Summary of symbols and notation used.

Symbols	Explanations
${\tau }_{Mn\left(com\right)}$	Main community
${\tau }_{Cr\left(com\right)}$	Credible community
$F\left(n_i\right)$	Friend node in the community
$M\left(n_i,n_j\right)$,	Mutual friends
$H{n}_i$	Honest and trusty nodes
$S{n}_i$	Selfish nodes
$SI\left(n_i,n_j\right)$	Social interactions of two nodes, i and j
$E^t\left(n_i\right)$	The energy of the node over time t
$\lambda$	Arbitrary constant to calculate the honesty Threshold value
$if{ }_{ }^t\left(n_i,n_j\right)$	Interaction frequency
$cr{ }_{ }^t\left(n_i,n_j\right)$	Credibility of node
$H{\left(n_i,n_j\right)}^t$	$\mathrm{Total} \mathrm{honesty} \mathrm{of} \mathrm{node} n_i$ to $n_j$
SCH	Selected Community Head
SMH	Selected monitoring Head
$E_k$	Events in the community
$f\nabla n_{x_i}$	Forward data
$g\nabla n_{x_i}$	Generated data
$d\nabla n_{x_i}$	Dropped data
$S{n}_{x_i}$	$\mathrm{Score} \mathrm{of} \mathrm{nodes} n_{x_i}$
$CPA{n}_{x_i}$	$\mathrm{Community} \mathrm{performance} \mathrm{assessment} \mathrm{of} \mathrm{nodes} n_{x_i}$
$NS{n}_{x_{i+1}}$	Node score in the community
$NJ{D}_k\left(n_{x_i}\right)$	Node score according to its neighbor
$RS{n}_{x_i}$	Reputation score of nodes to declare node as selfish or honest

shows the lists of symbols used in the equations. These symbols are also further explained in the text, along with the respective equations.

An honesty threshold value was calculated for network simulation. The proposed scheme deals differently with selfish nodes. The node with below-threshold selfish behavior will be separated into an isolated domain, and no communication will be performed with these nodes, rather than expelling them permanently from the community. However, a selfish node can rejoin the main community by increasing its honesty level beyond the threshold value. Such nodes will be given a chance to increase their honesty levels to become part of the main community again. If a node shows repeated selfish behavior, a message will be sent to the neighboring communities to stop communication with that node—a severe punishment. This message will be broadcast to all the neighboring communities to stop communication with nodes with constant selfish behavior. Figure 1 shows the system diagram.

This section is further divided into the subsections (a) Preliminaries and Assumptions, (b) Selection Module, and (c) Decision Modules.

3.1. Preliminaries and Assumptions:

The following are the proposed mechanism’s key assumptions and features:

3.1.1. Network Model

A diverse set of IoT nodes is assumed in the network. The network can be denoted by $N$ having a finite number of nodes $n_i$, where $i=1, 2, 3,\dots n$. The proposed network can be represented by Equation (1).

$$N=\left\{n_1, n_2, n_3, \dots , n_i\right\}$$

(1)

It is further assumed that each node $n_i$ has a transceiver and is capable of performing its data and network operations.

3.1.2. Communication Layers

The IoT network nodes may operate on different physical and network layers. However, it is assumed that the nodes are adequately equipped to communicate and easily translate each other’s data. The proposed mechanism mainly focuses on the data and communication patterns among the nodes. The roles of gateways or heterogeneity controls are not within the domain of this work. Moreover, wireless interfaces allow for promiscuous operation. This communication mode is assumed to be supported by the network nodes to enable the proposed procedures. Most of the present IEEE 802.11-based wireless devices allow such a promiscuous mode of operation.

3.1.3. Base Protocols

The base protocols can be traditional IP and IoT-based 6Lopan and ad hoc network-based DSR and AODV. However, the nodes should be capable of understanding each other, even with such diverse protocols.

3.1.4. Classification of Nodes

The network’s nodes can be classified as friend, mutual friend, selfish, or honest nodes.

A friend of node $n_i$ can be denoted as $F\left(n_i\right)$ that is present in the community and has active liking and trust ($ALT$) with the node $n_i$. A mutual friend of nodes $n_i$ and $n_j$,$M\left(n_i,n_j\right)$, refers to the common friend of two interacting friends in a community. A well-behaved node is an honest node in the community, which means node $H{n}_i$ transmits the data or messages correctly to its fellow nodes in a network. The neighbor’s node, $n_k$, denotes all those nodes that have direct interaction with nodes in the community. Additionally, the node does not try to modify history. Any node in the community that uses the resources of the other nodes for its purpose but does not serve the community with its resources, such as energy, bandwidth, link sharing, and storage space, can be described as a selfish node $S{n}_i$.

Equations (2)–(5) are used to define these nodes.

$$F\left(n_i\right)\in N: \left\{n_j\in N_{alive}\wedge n_j\in ALT\left(n_i\right) \right\}$$

(2)

$$M\left(n_i,n_j\right)\in N: \left\{n_k\in N_{alive}\wedge n_k\in ALT\left(n_i\right) \wedge n_k\in ALT\left(n_j\right)\right\}$$

(3)

$$H{n}_i \in N:\left\{n_i \in {\tau }_{cr} \vee {\tau }_{Mn\left(com\right)} ϵ N_{alive} \wedge n_i is trustful \right\}$$

(4)

$$S{n}_i\in N: \left\{n_i\in N_{alive}\wedge n_i is not in H{n}_i\right\}$$

(5)

where N is the total number of nodes which is between $\left(0, 1\right]$.

3.1.5. Community

It is a group of nodes with similar interests, the same geographical area, and mutual understanding. The nodes in the community socialize with each other to develop trust by sharing information. For example, a community of vehicles could be used to pick up and drop off kids at schools. These buses can share information regarding school opening times, school closing times, and traffic and events at the schools. A community of nodes can be denoted as $Com{m}_i$ having a set of nodes $\left\{n_i\right\}$ performing some functions, $Rol{e}_j$, as shown in Equation (6). There are two communities. The main community is represented by ${\tau }_{Mn\left(com\right)}$, and the credible community represented by ${\tau }_{Cr\left(com\right)}$.

$$Com{m}_i=\{n_i\in N_{alive} \wedge n_i: Rol{e}_i\}$$

(6)

3.1.6. Events

An event is any activity in a community where nodes patriciate for a specific period. For example, during weekdays school attendance, the vehicles provide pickup and drop-off to the kids. An event can be denoted as a $Rol{e}_i$ that chains different functions, $f_j$, as shown in Equation (7):

$$Rol{e}_i=\left\{f_1,f_2,f_3,\dots f_n\right\}$$

(7)

3.1.7. Social Interactions

While performing a particular role, the nodes may share information about the events. For example, vehicles attending some events might socialize with each other by sharing traffic information, parking information, accident emergency exits, and other social information, as shown in Equation (8).

$$SI\left(n_i,n_j\right)=\{History.Rol{e}_k\left(n_i\right) \vee History.Rol{e}_k\left(n_j\right)$$

(8)

3.1.8. Node Energy Level

There is a finite quantity of energy in each node. Different nodes have different energy levels in the network. The node is alive if it has sufficient energy to process, transmit, and receive the data in the network from other nodes. The current and initial energy levels of a node $n_i$ are $E\left(n_i\right)$ and $E_{Initial}\left(n_i\right)$, respectively. $E^t\left(n_i\right)$ is the node’s residual energy ratio at time $t$, as calculated by Equation (9).

$$E^t\left(n_i\right)=Initial\_E\left(n_i\right)-Consumed\_E\left(n_i\right)$$

(9)

3.1.9. Threshold Calculations

For the node to become part of the credible community, the node’s honesty level is compared with the threshold value, as calculated in Equations (10) and (11). Equation (12) is used to show the status of the node as credible. The threshold value monitors the honesty level of the node in our method and triggers actions when the honesty level of the node is less than the threshold value.

$${\tau }_{Cr\left(com\right)} \in (\lambda ,1] \in N: \{n_i \in H{n}_i where n_i>\lambda ϵ\left(0,1\right] \}$$

(10)

$${\tau }_{Mn\left(com\right)} \in \left(0,\lambda \right]\in N: \{n_i \in H{n}_i where n_i \le \lambda ϵ\left(0,1\right]$$

(11)

$$H{n}_i \in N:\left\{n_i \in {\tau }_{cr} \vee {\tau }_{Mn\left(com\right)} ϵ N_{alive} \wedge n_i is trustful \right\}$$

(12)

${\tau }_{cr}$ represents the credible community, ${\tau }_{Mn\left(com\right)}$ represents the main community, and $\lambda$ is an arbitrary constant assumed for calculating the threshold value for honesty from node $n_i$ to node $n_j$ $H{\left(n_i,n_j\right)}^t$.

3.2. Selection Module

In this phase of the selection process, a credible community is created from the main community based on the social behavior of nodes in the community. We have chosen honesty as a trust parameter to create a credible community from the main community.

3.2.1. Credible Community

The following metrics are used to calculate the honesty level of the node to become part of a credible community.

i.

Interaction frequency

Let us consider the conversation of nodes in the community involving the exchange of data: $Cn=\left\{c{n}_1, c{n}_2,c{n}_3, \dots c_{ni}\right\}$. The conversation made between trustee and trustor nodes, denoted by $n_i$ and $n_j$, over time t, is given in Equation (13).

$$if{ }_{ }^t\left(n_i,n_j\right)=\frac{\sum L\left(Cni\right)}{TL\left(Cni\right)}EL\left(C{n}_i\right)$$

(13)

where $\sum L\left(Cni\right)$ indicates the number of interactions between nodes, and $TL\left(Cni\right)$ indicates the total number of interactions. $EL\left(C{n}_i\right)$ is the entropy function that measures the usefulness of the conversation between the nodes calculated in Equation (14).

$$EL\left(C{n}_i\right)=-\mathsf{\phi }\log \mathsf{\phi }-\left(1- \mathsf{\phi }\right)\log \left(1-\mathsf{\phi }\right)$$

(14)

Here, $\mathsf{\phi }$ is the fraction of communication between the trustor and trustee node.

ii.

Credibility

Credible nodes consider each other trustworthy if they have common friends. The more common friends between two nodes, trustor i and trustee j, the higher the reliability of their communications. This can be calculated in Equation (15):

$$\begin{gathered} c{r}^t\left(n_i,n_j\right)=\frac{min\left\{n_i,n_j\right\}}{N\left(n_i\right)} \\ \Rightarrow c{r}^t\left(n_i,n_j\right)=\frac{n_{i }\wedge n_j}{N\left(n_i\right)} \end{gathered}$$

$$\Rightarrow c{r}^t\left(n_i,n_j\right)=\frac{M\left(n_i,n_j\right)}{N\left(n_i\right)} \left\{\mathrm{M} \left(n_i,n_j\right)ϵ\left(0,1\right],N\left(n_i\right)\ne 0\right\}$$

(15)

where $M\left(n_i,n_j\right)$ are the common friends of $i$ and $j,$ and $N\left(n_i\right)$ is the numbers of friends of the trustee.

iii.

Community Interest

Each node has interests in the community. A node that takes an interest in the community’s activities is likely to forward the relevant data to its connected nodes. It can be calculated in Equation (16):

$$\begin{gathered} c{i}^t\left(n_i,n_j\right)=\frac{Com{m}_i\left[min\left\{n_i,n_j\right\}\right]}{Com{m}_i\left[N\left(n_i\right)\right]} \\ \Rightarrow c{i}^t\left(n_i,n_j\right)=\frac{Com{m}_i[n_i\wedge n_j]}{Com{m}_i\left[N\left(n_i\right)\right]} \end{gathered}$$

$$\Rightarrow ci{ }_{ }^t\left(n_i,n_j\right)=\frac{Com{m}_i\left[M\left(n_i,n_j\right)\right]}{Com{m}_i\left[N\left(n_i\right)\right]} \left\{\mathrm{M} \left(n_i,n_j\right)ϵ\left(0,1\right],N\left(n_i\right)\ne 0\right\}$$

(16)

where $Com{m}_i\left[M\left(n_i,n_j\right)\right]$ is the common community of friends of the trustor and trustee nodes and $Com{m}_i\left[N\left(n_i\right)\right]$ is the common community of the friends of the trustee nodes.

The total honesty of node $n_i$ to node $n_j$ is calculated in Equation (17) by taking the sum of three metrics, as shown below:

$$H{\left(n_i,n_j\right)}^t= \alpha +\gamma +\delta$$

(17)

where $\alpha +\gamma +\delta =1$ and $\left\{\begin{array}{c}\alpha ={\beta }_{if}\ast if{ }_{ }^t\left(n_i,n_j\right)\\ \gamma ={\beta }_{cr}\ast cr{ }_{ }^t\left(n_i,n_j\right) \\ \delta ={\beta }_{ci}\ast ci{ }_{ }^t\left(n_i,n_j\right)\end{array}\right.$.

The total honesty of the node calculated in Equation (17) is compared with the threshold value calculated in Equations (10) and (11) when the network is setup. If the node’s honesty level is greater than the threshold value, the node is credible and becomes a member of the credible community. Otherwise, the node is not considered to become part of the credible community. The node is not selfish but not honest enough to be part of the credible community. The credible community includes all the nodes with honesty levels greater than the threshold value. The proposed scheme automatically changes the node’s state from the main community to the credible community if its honesty exceeds the threshold value. Algorithm 1 shows the creation of a credible community from the main community.

Algorithm 1 Credible community creation.

Ensure: Credible Community from Main Community

Require: Number of nodes n

Ensure: Credible Community from Main Community

Begin Create ${\tau }_{Cr\left(com\right)}\leftarrow {\tau }_{Mn\left(com\right)}$ Formation of ${\tau }_{Cr\left(com\right)}$ For i = 1: n do Compute $H{\left(n_i,n_j\right)}^{}$ of all Nodes in ${\tau }_{Mn\left(com\right)}$ $H{\left(n_i,n_j\right)}^t\leftarrow if{ }^t\left(n_i,n_j\right)+cr{ }^t\left(n_i,n_j\right)+ci{ }^t\left(n_i,n_j\right)$ Frequency of interactions$: if{ }^t\left(n_i,n_j\right)=\frac{{{\displaystyle \sum }}_{j}L\left(Cni\right)}{TL\left(Cni\right)}EL\left(C{n}_i\right)$ Credibility$: cr{ }^t\left(n_i,n_j\right)=\frac{M\left(n_i,n_j\right)}{N\left(n_i\right)}$ Community of interest: $ci{ }^t\left(n_i,n_j\right)=\frac{Com{m}_i\left[M\left(n_i,n_j\right)\right]}{Com{m}_i\left[N\left(n_i\right)\right]}$ $if (H{\left(n_i,n_j\right)}^t \ge \lambda )$ $node n_i=\mathrm{Credible} \mathrm{node}$ $node n_i$ Else $node n_i$ End if End for Exit

3.2.2. Heads Selection

In this section of the selection module, two heads are selected from the credible community based on the following criteria.

i.

Computation of Seniority:

In a community of nodes, the nodes join the community, make some social relationships with other nodes, and may leave over the period. The node that spends the most time in a community becomes its senior node. The senior node learns more about the community’s resources and its fellow nodes. Different events occur in a community. An event $k$ can be represented as $E{V}_k$, where $k=1, 2, 3,\dots ,m$ and $m$ is the total number of events. A node $n_i$ participating in an event $k$ for a time interval $t$ can be represented by $E{V}_k{\left(n_i\right)}^T$. The seniority of the node $n_i$ can be represented by Equation (18):

$$S\left(E{V}_k{\left(n_i\right)}^t\right)=T_{cur}-T_{reg}$$

(18)

where $t_{cur}$ is the current time and $t_{reg}$ is the registration or joining time of the node $n_i$.

ii.

Cooperative behavior.

A node is cooperative if it has more friends in the community to communicate with. More friends of the node mean it is more trustworthiness and cooperativity with the connected nodes in the community. Therefore, the cooperative behavior of a node $n_i$ towards node $n_j$ can be figured out as in Equation (19):

$$\begin{gathered} cb\left[n_i{}^T\right]=\frac{min\left\{n_i,n_j\right\}}{max\left\{N\left(n_i\right),N\left(n_j\right)\right\}} \\ \Rightarrow cb\left[n_i{}^T\right]=\frac{n_i\wedge n_j}{N\left(n_i\right) \vee N\left(n_j\right)} \end{gathered}$$

$$\Rightarrow cb\left[n_i{}^T\right]=\frac{M\left(n_i,n_j\right)}{N\left(n_i\right) \vee N\left(n_j\right)}$$

(19)

where, $M\left(n_i,n_j\right)$ is the total number of friends of nodes i and j and $N\left(n_i\right) \vee N\left(n_j\right)$ is the total number of common friends of nodes i and j.

iii.

Energy level:

The node energy is very important in the community. A node having high energy means it is alive and is taking an active part in the main events of the community. A node with a higher energy level is more cooperative than a node with a lower energy level. The node’s current energy level can be computed in Equation (20).

$$\Delta E\left(n_i\right)=\mathrm{Avg}(\Delta E^{t_i}(n_i)-\Delta E^{t_{i+1}}(n_i))$$

(20)

where $t_i$ represents the different uniform reading times. The energy fluctuation must satisfy the equation $E\left(n_i\right)>△E\left(n_i\right)$, after a given amount of time. Due to the SIoT heterogeneous environment, the value E may differ for each node.

iv.

Final Weights of Nodes:

The final weight of a node can be calculated in Equation (21).

$$fw\left[n_i{}^T\right]=s\left[E{V}_k{\left(n_i\right)}^T\right]+cb\left[n_i{}^T\right]+\left[E\left(n_i\right)/\Delta E\left(n_i\right)\right]$$

(21)

In Equation (21), the final weight $fw\left[n_i{}^T\right]$ of node $n_i$ determines the node’s status as a head node in the credible community. $fw\left[n_i{}^T\right]$ is the final weight of the nodes to be used for selecting heads of the community. The node having the highest value of $fw\left[n_i{}^T\right]$ is selected as the selected community head, SCH, and the node with the second highest value is selected as the selected monitoring head, SMH. The SCH is responsible for managing the nodes in a community and will make a decision based on the behavior of a given node in the community. The SMH monitors the behavior of nodes in the community. Suppose it observes a node with selfish behavior. It is reported to the SCH for further treatment. The node is isolated to a selfish domain if it shows selfish behavior, and a chance will be given to increase its honesty level. The SCH can also expel the selfish nodes if it shows repeated selfish behavior in the isolated domain. This process selects the heads in the community based on the final weight of the node in the community having attributes of seniority, cooperative behavior, and energy level.

Algorithm 2 shows the process for head selection.

Algorithm 2 Head selection.

Require: Number of all credible nodes n in Cr(Com)

Ensure: Selection of Different Heads in Cr(Com) and its Responsibilities

Begin For i = 1: n do Select Heads in${\tau }_{Cr\left(com\right)}$ such as SCH, SMH Compute the weight of each node in${\tau }_{Cr\left(com\right)}$ for head Selection Weight $=\left[E{V}_k{\left(n_i\right)}^T\right]$ + $\mathrm{c}b\left[n_i{}^T\right]$ + $\mathrm{c}b\left[n_i{}^T\right]$ $s\left[E{V}_k{\left(n_i\right)}^T\right]=t_{cur}-t_{reg}$ $\mathrm{c}b\left[n_i{}^T\right]=\frac{M\left(n_i,n_j\right)}{N\left(n_i\right) \vee N\left(n_j\right)}$ $\Delta E\left(n_i\right)=\left(n_i\right)/\Delta E\left(n_j\right)$ Higher weight in ${\tau }_{Cr\left(com\right)}\leftarrow \mathrm{SCH}$ Go back to step 5 and repeat steps 5, 6, 7 and 8 For i = 1: n−1 2nd higher weight in${\tau }_{Cr\left(com\right)}\leftarrow \mathrm{SMH}$ End for

3.3. Decision Module

In this module of our proposed scheme, the selfishness and honesty of the node’s performance are evaluated. Here, in our approach, the detection and punishment of selfish nodes are different from some of the current approaches [31,34,38]. The SMH in the community monitors the nodes’ behavior. It has direct communication with all the nodes in the community. The monitoring head monitors the value in the assessment table, and if it finds selfish behavior of the nodes in the community, it reports the SCH to act based on the node’s behavior. The SCH node is responsible for taking appropriate action against selfish nodes in the community. In our approach, the nodes with selfish behavior will be isolated to a separate domain, rather than expelling them permanently from the community. These selfish nodes will be given a chance to rejoin the community once their reputation scores reach a threshold value calculated in Equation (11) because the nodes can regain some energy and make memory free to start forwarding messages again. However, such nodes may be expelled from the network with repeated selfish behavior, as a severe punishment, and this message will be forwarded to all the nodes in the network. The decision module is subdivided into (i) performance evaluation of nodes, (ii) node score in the community, and (iii) node score according to its neighbor. Algorithm 3 shows the functions of two heads.

Algorithm 3 Heads functions.

Input: Available nodes in the community and its Assessment table

Output: node’s behavior

$\rho \leftarrow any number$ For each node j among the neighbor’s node of interacting node $n_{xi}$ Compute $S{n}_{x_i}=\left(f\nabla n_{x_i}+g\nabla n_{x_i}\right)-d\nabla n_{x_i}$ Compute $NS{n}_{x_{i+1}}=\frac{S{n}_{x_{i+1}}-min\left(CPA{n}_{x_i}\right)}{max\left(CPA{n}_{x_i}\right)-min\left(CPA{n}_{x_i}\right)}$ Compute $NJ{d}_k\left(n_x\right)$ of node $n_{xi}$ neighbor judgement Compute $RS{n}_{x_i}=\left(\frac{NS{n}_{x_{i+1}}+NJ{d}_k\left(n_{x_i}\right)}{2}\right)$ If $R{S}_{nxi}$ > $\rho$ Behaviour = “CPR” Else if $R{S}_{nxi}$ ⇐ $\rho$ Report to SCH Behavior = “SELF” Update $CPA{n}_{x_i}$ End if Each node SCH $\in {\tau }_{Cr\left(com\right)}$ If (Behavior = “selfish” reported by SMH) then Isolate node in a separate domain Else if (Behavior = “selfish” repeated) Expel the node from the community Broadcast this message in the community Update $CPA{n}_{x_i}$ End if End for

3.3.1. Performance Evaluation of Node

In a community, there are different events represented by $E_k$= $\left(\left\{n_{x_1},n_{x_2}.........n_{x_i}\right\},t^k\right)$, where 1≤ $n_i$ ≤ x_i and $n_{x_i}$ represent nodes. $E_k$ and $t^k$ indicate the occurrence of an event at time t. These nodes in the events forward and receive a set of data. The set of data forwarded by a node $n_{x_i}$ is represented as (forwarded data) $f\nabla n_{x_i}$, and the set of the data generated by the node $n_{x_i}$ is (generated data) $g\nabla n_{x_i}$. In the process, there are certain data bundles which are dropped and may not be relayed by node n_(x_i), which are represented as (dropped data) $d\nabla n_{x_i}.$ Equation (22) shows the nodes’ scores based on how they receive and process the data.

$$S{n}_{x_i}=\left(f\nabla n_{x_i}+g\nabla n_{x_i}\right)-d\nabla n_{x_i}$$

(22)

where $\nabla$ is the probable data bundles forwarded, generated, and dropped by node $n_{x_i}.$ When the nodes contact each other, they request the information needed to calculate their score $S{n}_{x_i}$. This score then becomes part of the community performance assessment table, which has the other nodes’ scores $S{n}_{x_i}$.

i.

Node Score in the community:

Each node in the community maintains a community performance assessment table $CPA{n}_{x_i}$. This table has information about all other nodes’ scores, $S{n}_{x_i}.$ While participating in the events, the nodes exchange information, $f\nabla n_{x_i}, g\nabla n_{x_i}, \mathrm{and} d\nabla n_{x_i}$ to build and calculate the node’s score,$S{n}_{x_i}$. This information is propagated in the community, and each node in the community keeps information of $S{n}_{xi}$ in the community assessment table. In this case, the nodes in the community may not directly interact with one another but will learn about nodes’ score (NS) through community performance assessment table’s updates. The score of a node in the community is given by Equation (23):

$$NS{n}_{x_{i+1}}=\frac{S{n}_{x_{i+1}}-min\left(CPA{n}_{x_i}\right)}{max\left(CPA{n}_{x_i}\right)-min\left(CPA{n}_{x_i}\right)}$$

(23)

$NS{n}_{x_{i+1}}$ shows the node score value of the encountered node $n_{x_{i+1}}$ in the overall network, whereas $S{n}_{x_{i+1}}$ shows the performance value of node $n_{x_2}$ computed by node $n_{x_1}$. $max\left(CPA{n}_{x_i}\right)$ shows the maximum and $min\left(CPA{n}_{x_i}\right)$ the minimum probable values recorded in the node assessment table of node $n_{x_i}$. Equation (23) shows how a node in a community performs relative to other nodes in a community. This value is propagated in the community starting from its neighbor node.

Algorithm 4 shows a node’s performance in the community.

Algorithm 4 Nodes performance in community.

$\mathrm{Input}: f\nabla n_{x_i},g\nabla n_{x_i} and d\nabla n_{x_i}$

Output: $NS{n}_{x_{i+1}}$

Begin $S{n}_{x_i}=\left(f\nabla n_{x_i}+g\nabla n_{x_i}+d\nabla n_{x_i}\right)$ Min $\leftarrow min\left(CPA{n}_{x_i}\right)$ Max $\leftarrow max\left(CPA{n}_{x_i}\right)$ If $S{n}_{x_i}$ > Max Max $\leftarrow S{n}_{x_i}$ Else Min $\leftarrow S{n}_{x_i}$ End if Broadcast $\hspace{1em}\hspace{1em}NS{n}_{x_{i+1}}=\frac{S{n}_{x_{i+1}}-min\left(CPA{n}_{x_i}\right)}{max\left(CPA{n}_{x_i}\right)-min\left(CPA{n}_{x_i}\right)}$

3.3.2. Node Score According to Its Neighbors

The neighbor assessment is very important in a community with few contacts to be made among the nodes. In other words, it is the score calculated based on the direct contact of the nodes with their neighbors. Thus, the assessment of the node in the network only is not sufficient to declare the node as selfish or honest. We need the neighboring nodes’ assessments to decide whether the node’s behavior is honest or selfish. At each contact made, the node’s performance is propagated to all N neighbors about its bundles of data which are accepted or rejected. The neighbor’s opinion score is calculated by Equation (24):

$$NJ{D}_k\left(n_{x_i}\right)=(\frac{{{\displaystyle \sum }}_{v=1}^{N}J{D}_v \left(n_{x_i}\right)}{N})$$

(24)

where $NJ{D}_k\left(n_{x_i}\right)$ represents the judgment of node k about node $n_{x_i}$ and N is the total number of neighbors of node $n_{x_i}$. Node v will evaluate the reputation of node $n_{x_i}$ based on the value of accepted bundles and rejected bundles for node v. The two values will be compared later to declare the node as selfish or honest in a reputation score calculation. The node score module (NS) will request all the neighbors to show their judgment about the contacted node. The requested information from all N neighbors has all the accepted bundles (AB) and rejected bundles (RB) from that node to them, and the judgment table is updated.

3.3.3. Threshold Value Calculation

The reputation score declares the node as honest or selfish. An honest node is a cooperative node, whereas a selfish node does not cooperate in forwarding the messages. The reputation score of the node is compared with the threshold value calculated in Equations (25)–(27).

$${\tau }_{Hni}\in \left(\rho ,1\right]\in N:\{n_{xi} ϵ RS{n}_{x_i} where n_{xi}>\rho \in \left(0,1\right] \}$$

(25)

$${\tau }_{Sni}\in \left(o,\rho \right]\in N:\left\{n_{xi} ϵ RS{n}_{x_i} where n_{xi} \le \rho \in \left(0,1\right] \right\}$$

(26)

$$RS{n}_{x_i} \in N:\left\{n_{xi} \in {\tau }_{Hni}\vee {\tau }_{Sni} \in NS{n}_{x_{i+1}}\vee NJ{d}_k \right\}$$

(27)

${\tau }_{Hni}$ represents honest nodes, and ${\tau }_{Sni}$ represents selfish nodes in the community. $\rho$ is an arbitrary constant assumed for calculating the threshold value for the node score $RS{n}_{x_i}$. The threshold value monitors the honesty level of the node in our technique and triggers actions according to the honesty level of the node. A node with a reputation score greater than the threshold value is cooperative; otherwise, it is declared as a selfish node.

3.3.4. Reputation Score

The reputation score (RS) of the node $n_{x_i}$ will determine the node as honest or selfish by taking values from Equations (23) and (24) and calculating the reputation score of the node in Equation (28):

$$RS{n}_{x_i}=(\frac{NS{n}_{x_{i+1}}+NJ{d}_k\left(n_{x_i}\right)}{2})$$

(28)

were $NS{n}_{x_{i+1}}$ is the reputation score of node $n_{x_i}$ throughout the network, and $NJ{d}_k\left(n_{x_i}\right)$ represents the scores calculated by all its neighbors. The decision module accepts or rejects the request made by the node by comparing the reputation score with the threshold value. If the reputation score exceeds the threshold value, then the node is trustworthy and will be allowed to communicate; otherwise, it will be declared as a selfish node and isolated to the selfish domain. No communication will be made with the nodes in the selfish domain. A message will be propagated to all the nodes in the community.

Algorithm 5 determines the node’s behavior as selfish/honest.

Algorithm 5 Node’s behavior (selfish/honest).

Input: node score $NS{n}_{x_{i+1}}$, node judgement $NJ{d}_k\left(n_{x_i}\right)$ Output: reputation score $RS{n}_{x_i}$ Begin If $RS{n}_{x_i}>\rho$ $n_{x_i}\leftarrow$ Honest node Allowed to communicate Else if $RS{n}_{x_{i }} \le \rho$ $n_{x_i}\leftarrow$ selfish node Isolate in a separate domain End if

4. Isolation of Nodes and Punishment

The reputation score determines the node’s behavior as honest or selfish. A more honest node in the community means more cooperation among the nodes to enhance the community’s performance. However, the selfish nodes can degrade the performance of the community, and some measures must be taken to reduce the number of selfish nodes. If the reputation score is less than the threshold value, the node will be declared selfish and isolated in a separate domain, and nodes will be unable to communicate with them. The selfish node will be given a chance to improve its reputation score and rejoin the community. If the node shows repeated selfish behavior, the SCH can punish the node by expelling it from the community. A message will be sent to all the nodes to refrain from communicating with selfish nodes.

5. Monitoring System

The SMH in the community monitors the behavior of the nodes. The monitoring head monitors the value in the assessment table and reports the SCH to act based on the node’s behavior. The node’s behavior depends on how many data bundles it sends that successfully reach their destinations, and a time delay in each data bundle is observed. Equation (29) calculates the ratio of data bundles received to data bundles generated.

$$D{\nabla }_{n_{x_i}}=\frac{R{\nabla }_{n_{x_i}}}{G{\nabla }_{n_{x_i}}}$$

(29)

$D{\nabla }_{n_{x_i}}$ is the data bundles delivered, $R{\nabla }_{n_{x_i}}$ is the number of bundles received at nodes x, and $G{\nabla }_{n_{x_i}}$ is the data bundles generated by node $n_{x_i}$.

6. Simulations Parameters and Performance Analysis

The effectiveness of the proposed Honesty-Based Social Technique (HBST) is evaluated in this section. The performance parameters considered are throughput, overhead, packet delivery ratio (PDR), and packet delivery latency. These measures are contrasted for two environments where different numbers of selfish nodes were introduced to examine their impact on the network. Selfish nodes can significantly reduce a network’s PDR, delivery delays, and routing overhead. It is essential to separate the selfish nodes to prevent any impact on the network’s overall performance.

Due to the selfish node’s lack of cooperation, packet delivery takes longer. To deliver the packets to their destinations on time, the cooperative nodes must therefore exert twice as much effort. As a result, the packages will take longer than usual to arrive at their destinations. When packets are kept in the node’s buffer for an extended period, the buffer becomes congested, leading to increased packet drops. The rise in dropped packets can also be attributed to the prevalence of selfish nodes. Selfish nodes do not collaborate, which causes the network to drop more packets and perform worse. The nodes depart from the protocol as a result of this. As a result, selfish nodes significantly affect the network nodes’ route information.

The overhead also influences the network’s performance. It reduces the network’s protocol bandwidth. The results demonstrate that the overhead caused by selfish nodes causes the network’s performance to decline as their number grows.

Table 4. Parameters used in the simulation.

Parameters	Values
Simulation field	1000 m2
Transmission radius	50 m
Base protocols	AODV
Pause time	10–100 s
Ratio of selfish nodes	25% & 50%
Threshold value used	Credible community, node selfishness
Comparison protocols	CAIS, HBDS, SSAR
Nodes distribution	Random
Packet size	Random
Type of channel	Wireless
Simulation duration	100 s

shows the parameters used in the simulation.

The proposed scheme was simulated and compared with the Copy Adjustable Incentive Scheme (CAIS) [20], Honesty-Based Democratic Scheme (HBDS) [34] and Social Selfishness Aware Routing protocol (SSAR) [46].

6.1. Comparison of Results with 25% Selfish Nodes in the Network

In this environment, 50 selfish nodes of 200 nodes were used, and the results were checked for performance metrics. Figure 2 shows the results for network throughput.

The proposed mechanism did not work effectively at the initial pause times, since the frequency of interactions heavily influences it. The throughput dramatically increases after pause time 20 when the communities were formed following the initial input operations. The throughput of the HBST began to increase as the community commutated and nodes began to show interest in the community. At pause time 60, HBST had a throughput that was 28.27% higher than that of the CAIS, 50% higher than that of the HBDS, and 56.52% higher than that of SSAR. Before pause 20, the continuous improvement in the throughput was due to detecting selfish nodes in the network by the HBST protocol and isolating them in a separate domain to improve the honesty parameters, and the increasing traffic volume.

The comparisons of routing overhead are shown in Figure 2—the nodes first exchange redundant control information to create the communities and their heads. More routing traffic is also required for tasks’ assignments. As a result, HBST initially has a higher routing overhead than CAIS, HBST, and SSAR protocols. When a community is first put up, nodes may quit it, and there is less frequent node interaction. The results show that by 10 s of pause time, HBST has an approximately 50% larger overhead than CAIS, 35.30% larger overhead than HBDS, and 27.46% lesser overhead than HBST for the SSAR protocol.

Given how the configuration was set up, the overhead of the HBST dramatically declined by the pause time of 30 s. The proposed mechanism’s overhead values are marginally better than its rivals. The overhead ratio of the HBST was 45.30% less than that of SSAR, 32.55% less than that of the HBDS, and 21.62% less than that of the CAIS at pause time 60. Similarly, at pause time 100, the overhead of the HBST dropped by around 20.60% compared to CAIS, 27.30% compared to HBST, and 44.90% less than SSAR. The findings show that the overhead of the HBST lowers as soon as the communities are established, nodes begin interacting with one another, and there is a rise in community interest. The isolation of selfish nodes also results in a lower overhead. The overhead ratio is reduced, since these nodes are separated and are not forwarded any communications. Figure 3 shows routing overhead ration for the network having 25% selfish nodes.

Figure 4 compares the proposed HBST’s PDR results to those of the CAIS, HBDS, and SSAR protocols. Over time, the PDRs of the experimented protocols rise. The performance of the proposed protocol is slightly worse than CIAS until pause time 30. At pause time 10, HBST’s PDR is 15.68% higher than that of the SSAR protocol, 3.77% less than that of the CAIS, and equal to that of the HBDS.

After the first setups were complete at pause time 30, the HBST performed at its best. The PDR of the HBST was 3.17% more than that of the CAIS, 14.28% more than that of the HBDS, and 18.46% more than that of the SSARat pause time 50. The PDR of the HBST was considerably increased at pause time 100 and was 10% better than that of the CAIS, 14.28% better than that of the HBDS, and 21% better than that of SSAR. The PDR of the HBST was initially somewhat smaller or equivalent to those of other protocols, as shown in the figure. However, as the community grows and more nodes show interest in it, the PDR of the HBST is improved. The reason for the higher PDR of the HBST at pause time 100 is that selfish nodes were separated from the main network and given time to enhance the qualities of the honesty parameter.

The network’s packet-delivery delays also influence the performance of a network. Network performance decreases as packet-delivery delays increase. Figure 5 compares the end-to-end delays of the proposed protocol with those of its competitors.

The findings indicate that once the community is established, nodes begin to show interest in it, and nodes engage in more interactions to create a credible community; HBST experiences the minimum delays. At stop time 10, the CAIS packet delay was 6.25% longer than that of the HBST, the HBDS’s delay was 9.10% longer, and the SSAR protocol’s delay was 12.54% longer. As a credible community is formed, the HBST delays get shorter, and the network’s performance gets better. The end-to-end delays of the HBST were 20% shorter than those of the CAIS, 36.7% shorter than those of the HBDS, and 42.86% shorter than those of the SSAR protocol at the end of the simulation. Reducing HBST end-to-end delays is attributable to excluding selfish nodes from communication.

6.2. Comparison of Results with 50% Selfish Nodes in the Network

The results for an environment having 50% selfish nodes—100 selfish ones out of a total of 200 nodes—are covered in this section. The rise in the number of selfish nodes also impacts throughput, overhead ratio, PDR, and packet delays. The current experiment followed the same protocols as the prior one. The results for the network having 50% selfish follow the same trends that are somewhat reminiscent of the first experiment. However, the values and performances have slightly declined because there are more selfish nodes.

Figure 6 compares the proposed protocol’s throughput results to those of the selected competitors. At pause time 10, HBDS and SSAR approaches outperformed HBST by about 15% and 10.52%, respectively, whereas CAIS’s throughput was approximately 19.05% higher than that of the HBST. At pause time 20, all three protocols—CAIS, HBDS, and SSAR—outperformed HBST’s throughput by roughly 17.40%, 9.52%, and 5%, respectively. At the initial stage, the throughput of the HBST was lower because the community was still growing, and nodes are not interacting frequently. The throughput of the HBST increased, as seen in the figure, and surpassed those of other approaches after establishing the credible community after pause time 20. The throughput of the HBST was 20% higher than that of the CAIS, 11.12% higher than that of the HBDS, and 37.78% higher than that of the SSAR at pause time 60. Similarly, the data reveal that HBST performs better than CAIS, HBDS, and SSAR at pause time 100.

The impact of the overhead ratio on network performance is depicted in Figure 7. The results show that HBST initially carries a greater overhead. The increased overhead is caused by the need to establish a trustworthy community, give nodes enough time to begin interactions with one another, and encourage nodes to take an interest in the community. As a legitimate community is established and grows, the overhead falls. At pause time 10, the overhead ratio of the HBST was 48.96% higher than that of the CAIS, 43.75% higher than that of the HBDS, and 41.67% higher than that of the SSAR. The other three approaches, CAIS, HBDS, and SSAR, have demonstrated a lower overhead ratio than the HBST at pause time 20. After establishing a credible community, the overhead ratio of the HBST began to improve. As seen in the results at pause time 60, the overhead ratio is 16.21% lower than that of the CAIS, 20.51% lower than that of the HBDS and 27.90% lower than that of the SSAR. Similarly, it improved further at pause time 100, achieving a lower overhead ratio.

The isolation of 50% of nodes from the main network also contributed to the improvement in the overhead ratio, as no communication was performed with the selfish nodes, decreasing the overhead ratio.

Figure 8 compares the PDR results of the proposed protocol to those from the CAIS, HBDS, and SSAR. At pause time 10, the PDR of the HBST was 17.5% lower than that of the SSAR method, 6.97% lower than that of the CAIS, and 2.43% lower than that of the HBDS. A lower PDR indicates that a credible community is developing. Results show that the PDR increases after developing a reliable community and once the nodes begin to show interest in the community. The PDR of the HBST was 10.34% lower than that of the CAIS, 15.51% lower than that of the HBDS, and 25% lower than that of the SSAR at pause time 60. The results show that the PDR of the HBST is superior to those of all three other methods at pause time 100.

Results for PDR in the prior experiment with 25% selfish nodes were marginally better than those in this experiment with 50% selfish nodes for all protocols. As fewer communication channels were constructed, and packet drops were more common, an increase in selfish nodes lowered the PDR.

The results for end-to-end delay are shown in Figure 9. The results show that once the network is set up, the HBST starts performing well. At stop time 10, the HBST’s packet delays were 7.40% shorter than those of the CAIS, 13.80% shorter than those of the HBDS, and 19.35% shorter than those of SSAR. As the nodes start communicating and a credible community is formulated, delays in the HBST decrease, as seen in the results. From pause time 30 to 100, it improves further. This is due to forming a credible community to forward messages to its neighbor nodes. At pause time 60, delays were 21.81% shorter than those of the CAIS, 23.56% shorter than those of the HBDS and 28.34% shorter than those of the SSAR. Similarly, at pause time 100, HBST had shorter delays than CAIS, HBDS, and SSAR techniques by 22.5%, 41.87% and 48.34%, respectively.

There were 50% selfish nodes in the network, which our technique separated from the main network, so no communication was performed with these selfish nodes in our scheme. This decreased the delays in the network, as no communication was possible with selfish nodes until they improved their honesty levels.

7. Conclusions and Future Work

In this paper, we have proposed a novel technique for SIoT networks to deal with the selfish behavior of nodes. If the selfish behavior of the nodes is not addressed, it can degrade the performance of the network and reduce the network’s basic value. HBST is a social technique to enhance the cooperation level of the nodes in the network, using honesty as a performance parameter. Unlike many other techniques that permanently expel the selfish nodes from the network, the proposed technique creates a separate domain for the selfish nodes and prevents all other honest nodes from communicating with selfish nodes. The selfish nodes in the isolated domain are given a chance to improve their behavior and become part of the network again.

The simulation results have shown that the proposed mechanism has greatly improved the network’s performance with the presence of selfish nodes. The key performance metrics are throughput, overhead ratio, PDR, and packet delay. In the future, nodes will also be given incentives or isolation from the main network to improve their behavior. In addition, incentives for game-based models dealing with virtual currencies can also be incorporated. The existing scheme can also be updated to avoid the selfish behavior of nodes in the network.