Social Trust Confirmation-Based Selfish Node Detection Algorithm in Socially Aware Networks

Abstract

Nodes in socially aware networks (SANs) may act selfishly on individual bases due to resource constraints and socially selfish behavior arising from the social preferences of nodes. In response to such selfish behaviors exhibited by nodes, this paper proposes a social trust confirmation-based selfish node detection algorithm (STCDA). This algorithm first utilizes a subjective forwarding willingness detection mechanism to discern selfishness. If a node’s energy is insufficient or its message rejection rate is too high—that is, the node cannot or is unwilling to forward messages—it indicates that the node is selfish. Otherwise, it is evaluated more thoroughly through the node’s social trust detection mechanisms. It calculates the social trust level of nodes based on the benefits of forwarding messages, thereby distinguishing between individually selfish nodes and socially selfish nodes in the network. If further evaluation is needed, the final judgment will be made using the message confirmation feedback detection mechanism. This checks the message information forwarded by nodes in the network. If nodes fail to forward messages after receiving them—excluding reasons such as message expiration or temporary insufficient cache space—it indicates that the nodes are selfish. Results from experimental simulations show that this algorithm performs better than traditional algorithms. Under conditions of 80% selfish nodes, a message TTL of 300 min, and 10 MB of cache space, it improves the message delivery rate by 5.87% and reduces the average delay by 6.2% compared to the existing comprehensive confirmation-based selfish node detection algorithm.

1. Introduction

The rapid growth of modern internet technologies is fundamentally changing social structures and people’s lifestyles. The swift progress in wireless communication [1], networking, and sensor technologies has led to significant advancements [2,3], and ubiquitous network architectures are gradually forming. Countless intelligent mobile devices are swiftly connecting to the network at an unprecedented pace, with their proportion steadily increasing, enabling the extensive adoption of social networking applications. In the “Internet Plus” era, where “everyone is connected”, the number of internet users in China is continuously surging, and the internet penetration rate is escalating. Statistics indicate that as of June 2023, the number of internet users in China had escalated to 1.079 billion, achieving an internet penetration rate of 76.4%. Among these, smartphones have become the primary devices for internet access. However, the substantial network connectivity demands of numerous intelligent mobile devices have led to excessive communication loads on traditional cellular networks, severely impacting the quality of service for applications. The rise of this trend has led to the development of socially aware networks (SANs) [4]. SANs is introduced by integrating delay tolerant networking (DTN) [5], information physical systems, and social network analysis theory [6,7]. SANs is proposed. As a novel network paradigm, SANs is capable of perceiving and analyzing the contextual information from network nodes [8,9], thereby enabling the fusion of human society with network physical systems through context-aware computing. This allows mobile networks to offer more intelligent and high-quality services to humanity [10].

The core design concept of SANs, as a wireless communication mode, is to fully utilize the social connections or characteristics between mobile nodes in the network. It primarily investigates how to achieve high efficiency in wireless communication between nodes in this mode. However, due to today’s high demands on battery life and storage space of smart devices [11], along with the limitations in resources and processing capacity of network nodes [12,13], these nodes cannot unconditionally support continuous operation. Therefore, nodes in the network may be unwilling to unconditionally sacrifice their self-interest to relay messages for other nodes [14,15], showing individual selfishness. At the same time, due to the differences in social relationships between people carrying smart mobile devices, they will have their own different behaviors. This dynamic change in topology increases the difficulty of network management, causing nodes to display social selfishness or even maliciousness. The addition of such nodes will have a serious impact on the network performance, reducing the throughput of the network, so that the network cannot work properly. Therefore, research on how to precisely detect selfish nodes in SANs and prevent their message forwarding is of great practical significance.

2. Related Works

Lately, a multitude of researchers have explored how nodes’ selfish actions affect the performance of SANs and have suggested diverse routing strategies for SANs architectures [16,17,18]. However, the premise of these studies is that all nodes in SANs are fully cooperative, which is not valid in the real world. Selfish behavior exhibited by nodes can severely affect network performance. Li et al. [19] established that selfish behavior negatively influences network performance, beginning with the nodes’ selfish actions. Li et al. [20] analyzed selfish behaviors, such as message rejection and message dropping by nodes, and modeled them using Markov chains. Through experimental analysis of two-hop routing and epidemic routing [21] strategies, they revealed that both selfish behaviors deteriorate network performance and increase latency. They suggested that a rise in the count of selfish nodes would lead to a reduced message delivery rate and heightened latency. Wang et al. [22] modeled message propagation and evaluated the effects of social and individual selfish behavior on hop-limited flooding strategies using corresponding mathematical models. Shan et al. [23] quantitatively analyzed the impact of static selfish nodes and dynamic selfish nodes on network performance from aspects such as mobility and proportion, density, and combination. The theoretical results indicate that selfish behavior significantly reduces network performance.

Currently, techniques for identifying selfish nodes primarily encompass mechanisms, watchdog mechanisms, confirmation message detection mechanisms, autonomous detection mechanisms, and reputation detection mechanisms for monitoring neighboring nodes. Marti et al. [24] were the first to propose the watchdog mechanism in literature, aiming to identify improper behavior nodes. This mechanism relies on the passive monitoring of neighboring node forwarding actions to evaluate their behavior, but it cannot determine whether data packets have been successfully received through the receiver on the subsequent hop in the link. Hernández et al. [25] proposed a collaborative watchdog scheme for rapid propagation based on selfish node awareness and developed an analytical model to assess this strategy’s efficiency in relation to detection timing and network overhead. Balakrishnan et al. [26] introduced the TWOACK detection method to determine node selfishness. This method checks whether each relay node sends acknowledgment messages to the two previous nodes during the process of message delivery from the source node to its destination, thereby validating the behavior of the relay node. Building on the TWOACK detection method, Liu et al. [27] proposed a 2ACK scheme in which a node sends a double-hop acknowledgment message (2ACK) to its previous node after receiving data from the previous node and successfully forwarding it to the next node to confirm the successful data transmission. However, this detection mechanism may increase the additional routing burden. Bigwood et al. [28] proposed a self-detection algorithm named IRONMAN, in which each node in the network records its interaction history with other nodes. IRONMAN identifies selfish nodes by analyzing these data. The algorithm initially sets the initial reputation level based on user-provided self-reporting information, and then nodes elevate the reputation score of the corresponding node after receiving information from the relay. Behrouz et al. [29] introduced a new detection method based on reputation, which further enhances the effectiveness of the watchdog detection mechanism. This method adjusts the reputation calculation and updates for other nodes not only based on direct observation but also through indirect information, thereby identifying node selfish behavior based on these reputation values. Fayaz et al. [30] suggested a method for detecting selfish nodes based on reputation, which calculates node selfishness based on energy consumption and contribution information, reflecting the node’s behavioral history through the ratio of resource consumption to contribution.

Each of the above methods demonstrates certain effectiveness, but they also have their respective limitations. At the current stage, researchers focusing on selfish node detection algorithms mainly concentrate on employing strategies that integrate multiple detection mechanisms to address the selfish detection problem. Xiao et al. [31] proposed a diversity-based selfish node detection algorithm (DSNDA), which identifies node selfish behavior through a combination of node forwarding intention, reputation, and confirmation of message approach mechanisms. If any of these three approaches expose a node’s selfish traits, it will be excluded from the data transmission process, thereby improving network efficiency. This detection algorithm utilizes the confirmation message mechanism and combines it with the other two mechanisms, effectively reducing the impact of confirmation messages on network overhead and energy consumption. However, this algorithm does not consider the occurrence of social selfishness among nodes. Moreover, using node caching as a criterion for determining selfish behavior may lead to cooperative nodes being mistakenly identified as selfish due to temporary cache shortages. Additionally, the confirmation mechanism fails to cover the possible delayed packet loss behavior of selfish nodes, thus posing a risk of misjudgment. Xiong et al. [32] introduced a comprehensive confirmation-based selfish node detection algorithm (CCSDA) in the literature. This algorithm detects selfish behavior in nodes using a reputation detection system and an interaction-based detection method, where nodes use a reputation assessment model to calculate a comprehensive reputation value and thereby discern whether nodes exhibit selfish behavior. For nodes with a high reputation, the algorithm employs an interaction-based detection method to monitor their behavior, thereby reducing energy consumption. To mitigate the negative impact of misjudging normal nodes on network performance, the algorithm further evaluates suspicious nodes with low reputations using the interaction-based detection mechanism. Yet, the algorithm overlooks the potential for social selfishness to arise among nodes, and its judgment of node selfishness is not comprehensive enough, thus posing a risk of misjudgment.

According to the above analysis results, this paper suggests a social trust confirmation-based selfish node detection algorithm (STCDA) based on social trust confirmation. It focuses on precisely detecting selfish nodes and actively bypassing them in path selection to avoid using selfish nodes during message forwarding. The algorithm first designs a subjective forwarding intention detection mechanism depending on the message rejection rate and the node’s remaining energy. If selfishness cannot be detected through this mechanism, the algorithm proceeds to the node’s social trust detection mechanism. By calculating the benefits of message forwarding, the algorithm evaluates the normal trust level, individual selfish trust level, and social selfish trust level to identify individually selfish nodes and socially selfish nodes. If selfishness still cannot be detected through the social trust detection mechanism, the algorithm performs a final determination using a confirmation feedback detection mechanism. It checks whether the node receives messages but does not forward them and whether there is message-dropping behavior, thus determining selfishness.

Finally, the algorithm is validated through simulation experiments, and the performance analysis of simulation results is conducted from various aspects.

3. Network Model and Assumptions

3.1. Network Model

SANs adopts a “store-carry-forward” data transmission mode. In the network, nodes depend on chance meetings to pass on messages. Consequently, this paper conceptualizes SANs as an undirected graph, symbolizing the complete collection of nodes within the network and illustrating the connections among all nodes. It can be seen in detail in Figure 1. In SANs, message transmission to the intended destination occurs via interactions and movements among nodes, establishing a cycle of message delivery. The message’s originator is known as the source node, node in the middle that receives the message is the intermediate node, and the ultimate receiver is termed the destination node.

3.2. Assumptions

The analysis in this paper will be based on the following assumptions:

• If a relay node is marked as selfish, it is assumed that the node is not the final recipient of the message. It will either reject messages from any other node or discard messages it has received;
• Selfish nodes do not engage in malicious activities, and nodes within the network do not alter their data information arbitrarily;
• Every node in the network possesses a distinct identifier, along with initial energy levels and cache capacity. Should a node’s energy be exhausted, it will automatically withdraw from the network.

4. Social Trust Confirmation-Based Selfish Node Detection Algorithm (STCDA)

The STCDA algorithm proposed in this paper mainly uses a subjective forwarding willingness detection mechanism, the node’s social trust detection mechanism, and the message confirmation feedback detection mechanism to detect the selfish nodes in the network. If any of these mechanisms detect a node as selfish, it will be separated from the network to prevent these nodes from affecting the efficient transfer of messages between source and destination nodes, thereby improving message delivery rates.

4.1. Subjective Forwarding Willingness Detection (SFWD) Mechanism

Nodes in SANs have limited energy and cache space. During message transmission, energy is consumed and cache space is occupied, leading to behavior where nodes are unwilling to expend their own resources to provide message-forwarding services to others, exhibiting selfishness. The suggested node subjective forwarding willingness detection (SFWD) mechanism primarily analyzes a node’s selfishness based on its remaining resources, focusing on energy constraints and message rejection rates.

4.1.1. Energy Constraints of Nodes

The energy constraints of nodes refer to the selfish behavior exhibited by nodes due to energy limitations. Nodes consume energy in the network to forward messages. If a node has sufficient remaining energy, it is more capable of forwarding messages. Conversely, if a node’s residual energy is inadequate, it may not be willing to forward messages due to its energy deficiency. Therefore, the selfishness of nodes is determined by comparing the node’s residual energy with the minimum energy required for message forwarding in the network. Let $E_{remain}$ represent the remaining energy of the node, and  $E_{min}$ represent the minimum energy that message forwarding is required in the network.

4.1.2. Message Rejection Rate of Nodes

The message rejection rate (RMR) mainly indicates the extent to which nodes reject incoming messages, defined as the ratio of the total number of rejected messages to the total number of message-forwarding requests received by the node. While the remaining cache space of a node also affects its message-forwarding capabilities, a node may reject incoming messages when its remaining cache space is temporarily insufficient. To prevent misjudgments of node selfishness due to temporary cache space insufficiency, the node’s message rejection rate is calculated, and a certain threshold is set to determine the node’s selfishness. Therefore, the (RMR) of a node can be represented by Equation (1):

$$RMR={\displaystyle \frac{Su{m}_{rej}}{Su{m}_{req}}}$$

(1)

where $Su{m}_{rej}$ denotes the sum of messages a node has declined, and $Su{m}_{req}$ signifies the aggregate number of requests for message forwarding that the node has encountered. In summary, the detailed detection steps of the node subjective forwarding intention detection mechanism are as follows:

(1)

If $E_{remain}⩽E_{min}$, indicating that the residual energy of node is too low to support message forwarding, the node will exhibit selfish behavior by refusing to provide message-forwarding services. At this point, the node is selfish, and there is no need to consider the node’s message rejection rate because the node lacks the energy to forward messages and thus will not receive messages either.

(2)

If $E_{remain}>E_{min}$, indicating that the residual energy of node is sufficient, and the node can expend some energy to forward messages, further consideration of the node’s message rejection rate is conducted to assess its selfishness.

(3)

If $RMR>RM{R}_{min}$ (the minimum threshold of message rejection rate that indicates node selfishness), this suggests that the node’s message rejection rate is excessively high. Even if some nodes reject messages due to a temporary insufficiency of cache space, a high RMR suggests a greater likelihood that the node is refusing messages to conserve cache space, thereby marking the node as selfish.

(4)

If $RMR⩽RM{R}_{min}$, indicating that the node’s selfishness is likely due to temporary insufficiency of cache space, this suggests that there may be some rejection of the received messages. This, however, cannot prove that the node is selfish. Therefore, when the node’s subjective forwarding intention detection mechanism cannot determine selfish nodes, further judgment is made using the node’s social trust detection (STD) mechanism.

The node subjective forwarding intention detection mechanism process is illustrated in Figure 2. The specific algorithmic process is shown in Algorithm 1.

The detection algorithm of the SFWD mechanism is shown in the figure above. Algorithm 1 outlines the method for identifying selfish behavior in nodes through SFWD. The algorithm takes the following inputs: $E_{remai{n}_i}$, the residual energy of node i; $E_{min}$, the threshold energy node i needs to forward messages; $RM{R}_{min}$, the minimal acceptable rate of message reception for node i; $Su{m}_{re{j}_i}$, the count of messages node i has refused; and $Su{m}_{re{q}_i}$, the count of message forwarding requests received by node i. The output of the algorithm is a Boolean value, where YES suggests node is acting selfishly, and NO indicates otherwise. Initially, if node i’s remaining energy is at or below the threshold for forwarding messages, this suggests selfishness. If not, the algorithm compares node i’s rate of message rejection against the minimal rate of message reception. If it is, proceed to the next determination using the STD mechanism; if not, node i is selfish.

Algorithm 1 SFWD algorithm

Input: $E_{remai{n}_i}$, $E_{min}$, $RM{R}_{min}$, $Su{m}_{re{j}_i}$, $Su{m}_{re{q}_i}$ Output: Boolean Value   1:  if $E_{remai{n}_i}\le E_{min}$ then   2:        Boolean Value = YES   3:  else   4:        $RM{R}_i={\displaystyle \frac{Su{m}_{re{j}_i}}{Su{m}_{re{q}_i}}}$   5:        if $RM{R}_i>RM{R}_{min}$ then   6:              Boolean Value = YES   7:        else   8:              Apply STD Algorithm to judge    9:       end if 10: end if

4.2. The Node’s Social Trust Detection (STD) Mechanism

The crux of the node’s social trust detection (STD) mechanism is to calculate the social trust of nodes and analyze their selfishness. Due to the limited resources and varying social relationships of nodes in SANs, nodes may exhibit individual selfishness and social selfishness to a certain extent. Therefore, calculating the individual and social benefits of node message transmission, and combining them to obtain comprehensive benefits, allows for the supervision and analysis of node benefits. This helps identify possible selfish behaviors and their severity, determine the social trust of nodes, distinguish between individually selfish and socially selfish nodes, and add selfish ones to the selfish list.

4.2.1. Selfish Node Model

Selfish behavior in nodes can be divided into two types: individual and social, resulting in the identification of nodes as either individually selfish or socially selfish. Individually selfish nodes are inclined to transmit their own messages and are also likely to hold and pass on messages from others, particularly if there is a high chance those messages will reach their intended destinations through these nodes. Consequently, for a message, m, to be forwarded, the individual benefit of node i$I{E}_i\left(m\right)$ is defined as Equation (2):

$$I{E}_i\left(m\right)=\left\{\begin{array}{cc}1,\hfill & src\left(m\right)=i\hfill \\ 1-{\displaystyle \frac{T_{i,des\left(m\right)}}{TTL}},\hfill & otherwise\hfill \end{array}\right.$$

(2)

where $src\left(m\right)$ represents message m’s source node, $T_{i,des\left(m\right)}$ represents the expected delay time for m to transfer from node i to its destination node. $TTL$ represents the lifespan of m. Additionally, when node i sends local messages, it brings the highest individual benefit. When forwarding non-local messages, if the expected delay time for the message to reach its destination is better than the message’s lifespan, it brings the highest individual benefit to the node, as indicated by Equation (2).

For socially selfish nodes, they will forward their local messages and also receive or forward non-local messages of intermediate nodes according to the strength of their social relationships. Hence, for a message, m, to be relayed, its social benefit to node i, denoted as $S{E}_i\left(m\right)$, can be characterized as Equation (3):

$$S{E}_i\left(m\right)=\left\{\begin{array}{cc}1,\hfill & src\left(m\right)=i\hfill \\ 1-{\displaystyle \frac{S{R}_{i,src\left(m\right)+S{R}_{i,j}}}{2}},\hfill & otherwise\hfill \end{array}\right.$$

(3)

where $S{R}_{i,src\left(m\right)}$ represents the social relationship from node i to message m’s source node, $S{E}_i\left(m\right)\in [0,1]$. And $S{R}_{i,j}$ represents the social relations from node i to the sender node, j, who sends message m to i.

Additionally, for individually selfish nodes, their comprehensive benefits are determined solely by their individual benefits, while for socially selfish nodes, their comprehensive benefits are determined jointly by their individual and social benefits. Hence, message m’s comprehensive benefit to node i$C{E}_i(m,{\delta }_i)$ can be defined as Equation (4):

$$C{E}_i(m,{\delta }_i)=(1-{\delta }_i)\ast I{E}_i\left(m\right)+{\delta }_i\ast S{E}_i\left(m\right)$$

(4)

where $I{E}_i\left(m\right)$ represents message m’s individual benefit to node i, represents message m’s social benefit to node i, and ${\delta }_i$ represents the social consciousness level of node i and ${\delta }_i\in (0,0.5]$. When ${\delta }_i=0$, it denotes that node i is individually selfish, while when ${\delta }_i=0.5$, it indicates that the individual and social benefits of the message, m, to node i are equally important.

In summary, for selfish node, i, as time passes, its message-forwarding order when performing message forwarding has an impact on its benefits as shown in Figure 3.

4.2.2. Node’s Social Relationships and Social Awareness Level

The social relations between nodes in the social-aware networking significantly affect the nodes’ selfishness, especially for socially selfish nodes. Apart from resource constraints, if the social relationship between two nodes is closer, they are more likely to voluntarily cooperate in message delivery. The degree of social awareness of nodes is an important factor in calculating the benefits of message forwarding.

(1) Social relationships (between nodes).

This paper examines historical data of nodes, including the frequency and duration of contacts, along with their interaction patterns, to predict the social relationships among nodes (SR) in SANs.Additionally, the degree of social similarity between nodes plays a role in shaping their social connections. Therefore, the social relationship between nodes is determined by both the social pressure measure (SPM) and social similarity (socsim). The descriptions of social pressure measure and social similarity are as follows:

• Social pressure measure (SPM) is a new method for measuring the intimacy of node relationships based on three characteristics: frequent, sustained, and consistent interactions. That is, nodes are deemed as friends if they engage in regular and frequent communication over an extended duration. Consequently, the formula $SP{M}_{i,j}$ to determine the social pressure metric between node i and j at time t is outlined in Equation (5) as follows:

  $$SP{M}_{i,j}={\displaystyle \frac{\begin{array}{c}{\int }_{t=0}^{T}f\left(t\right)\mathrm{d}t\end{array}}{T}}$$

  (5)

  where $f\left(t\right)$ represents the remaining time until the next encounter between both nodes at time t. If two nodes are connected at time t, then $f\left(t\right)=0$. Otherwise, $f\left(t\right)=t_{next}-t$. $t_{next}$ is the time until their next encounter. T denotes the effect on $SP{M}_{i,j}$ of all encounters between two nodes in the time interval [0, T] at some point in the experimental run.
• Social similarity (socsim) is quantified by the count of mutual neighboring nodes shared by two nodes, reflecting their level of resemblance. Therefore, the formula for assessing the social similarity between node i and node j is presented in Equation (6) as $socsi{m}_{i,j}$:

  $$socsi{m}_{i,j}={\displaystyle \frac{com{m}_{i,j}}{nb{r}_i+nb{r}_j-com{m}_{i,j}}}$$

  (6)

  where $com{m}_{i,j}$ denotes the common neighbor nodes’ number between node i and j, $nb{r}_i$ denotes the total number of neighbor nodes of node i, and $nb{r}_j$ denotes node j’s total neighbor node’s number.
  Since the social relationship, SR, between nodes is jointly determined by the social pressure measure, SPM, and social similarity socsim, according to the definitions of Equations (5) and (6), and the social relationship between node i and j. $S{R}_{i,j}$ can be presented as Equation (7):

  $$S{R}_{i,j}=\mu SP{M}_{i,j}+(1-\mu )socsi{m}_{i,j}$$

  (7)

  where $\mu$ is the weighting factor that influences the importance of factor $SP{M}_{i,j}$ and $socsi{m}_{i,j}$ to $S{R}_{i,j}$. $\mu \in [0,1]$.

(2) Node’s social awareness level.

As discussed in Section 4.2.1, both individually selfish nodes and socially selfish nodes transmit messages in descending order of benefits, aiming to maximize their routing performance. Therefore, in the STD mechanism, the analysis of the message-forwarding sequence of nodes can be used to determine the potential selfish categories of nodes. As Figure 2 shows, when node i is an individually selfish node, it instinctively forwards local messages first to maximize its individual benefit, followed by transmitting non-local messages in descending order of individual benefits. When node i is a socially selfish node, it forwards messages in descending order of its comprehensive benefit, where the calculation of the node’s comprehensive benefit must first consider its level of social awareness. Socially selfish nodes may allocate the highest benefit to non-local messages, while individually selfish nodes always allocate the highest benefit to local messages. Therefore, the attributes of the node’s message forwarding can be used to distinguish between individual selfishness and social selfishness.

In summary, the Equation (8) for calculating the social awareness level of node i is as follows:

$${\delta }_i=min(0.5, avg({\delta }_i,{\displaystyle \frac{S{E}_i\left(m\right)}{I{E}_i\left(m\right)+S{E}_i\left(m\right)}}))$$

(8)

where $S{E}_i\left(m\right)$ represents the social benefit of message m to node i, $I{E}_i\left(m\right)$ denotes message m’s individual benefit to node i, and ${\delta }_i\in (0,0.5]$. From Equation (8), it can be observed that as $S{E}_i\left(m\right)$ increases, node i’s social awareness level ${\delta }_i$ increases, indicating that when node i receives information from other nodes with close social connections and forwards it, its social awareness level will increase. If node i only forwards local messages, its social awareness level is 0. Otherwise, ${\delta }_i$, starting with the smallest positive number as the base, it is updated for each forwarded message individually. The algorithm for calculating the social awareness level is shown in Algorithm 2. The algorithm input $Messag{e}_i$ is the set of all messages forwarded by node i, and the output is the social awareness level ${\delta }_i$.

Algorithm 2 Calculate social awareness degree

Input: $Message{s}_i$ Output: ${\delta }_i$   1:  Initialize: ${\delta }_i=null$   2:  for each $m\in Message{s}_i$ do   3:        if $sr{c}_m==i$ then   4:              ${\delta }_i=0$;   5:              Continue;   6:        else   7:              Break;   8:        end if   9:  end for 10:  if  ${\delta }_i==null$  then 11:        ${\delta }_i=\vartheta$; 12:  end if 13:  for each $m\in Message{s}_i$ do 14:        update ${\delta }_i$ based on m; 15:        ${\delta }_{\mathrm{i}}=min\left(0.5,avg\left({\delta }_{\mathrm{i}},{\displaystyle \frac{S{E}_{\mathrm{i}}\left(m\right)}{I{E}_{\mathrm{i}}\left(m\right)+S{E}_{\mathrm{i}}\left(m\right)}}\right)\right)$; 16:  end for 17:  return  ${\delta }_i$

4.2.3. Update of Node’s Social Trust

The social trust of a node is divided into normal trust, individually selfish trust, and socially selfish trust. Normal trust refers to the likelihood of exhibiting altruistic behavior, individually selfish trust indicates the likelihood of a node being an individually selfish node, and socially selfish trust denotes the likelihood of a node being a socially selfish node. After confirming the node’s social awareness level, the social trust is updated by analyzing whether the comprehensive benefits of message forwarding are in descending order and considering the attributes of the messages, thereby determining individually selfish and socially selfish nodes. For the forwarded message, m, the normal trust, $N{T}_i\left(t\right)$, individually selfish trust, $IS{T}_i\left(t\right)$, and node i’s socially selfish trust at time t, $SS{T}_i\left(t\right)$, are presented by the following Equations (9)–(11), as follows:

$$N{T}_i\left(t\right)=1-C{E}_i(m,{\delta }_i)$$

(9)

$$IS{T}_i\left(t\right)=I{E}_i\left(m\right)$$

(10)

$$SS{T}_i\left(t\right)=S{E}_i\left(m\right)$$

(11)

Since most of the nodes will not forward only one message, each forwarded message will have an impact on the node benefits. After a period of time, the normal trust $N{T}_i\left(t\right)$, individually selfish trust $IS{T}_i\left(t\right)$, and node i’s socially selfish trust at time t $SS{T}_i\left(t\right)$ are updated by the following Equations (12)–(14):

$$N{T}_i\left(t\right)={\displaystyle \frac{N{T}_i(t-\Delta t)+N{T}_i\left(t\right)}{2}}$$

(12)

$$IS{T}_i\left(t\right)={\displaystyle \frac{IS{T}_i(t-\Delta t)+IS{T}_i\left(t\right)}{2}}$$

(13)

$$SS{T}_i\left(t\right)={\displaystyle \frac{SS{T}_i(t-\Delta t)+SS{T}_i\left(t\right)}{2}}$$

(14)

Here, $N{T}_i(t-\Delta t)$ represents node i’s normal trust at time $t-\Delta t$, $IS{T}_i(t-\Delta t)$ represents node i’s individually selfish trust at time $t-\Delta t$, and $SS{T}_i(t-\Delta t)$ denotes node i’s socially selfish trust at time $t-\Delta t$.

The update algorithm for node social trust is shown in Algorithm 3. Algorithm input: $Messag{e}_i$, all messages forwarded by node i. Algorithm output: $N{T}_i\left(t\right)$, node i’s normal trust at time t, $IS{T}_i\left(t\right)$, node i’s individually selfish trust at time t, $SS{T}_i\left(t\right)$, node i’s socially selfish trust at time t. First, calculate node i’s social awareness level, then check node i’s forwarded message comprehensive benefits. If the benefits are not in descending order based on the forwarding sequence, it indicates that node i did not exhibit selfish behavior in message forwarding. Otherwise, if node i showed selfish behavior in message forwarding, updates can be performed using Equations (12)–(14). The time complexity of the STD is $O\left(\right|Messag{e}_i\left|\right)$, where n is the total number of messages forwarded by node i.

Algorithm 3 Update node social trust

Input: $Message{s}_i$ Output: $N{T}_i\left(t\right)$, $IS{T}_i\left(t\right)$, $SS{T}_i\left(t\right)$   1: Initialize: $N{T}_i\left(t\right)=IS{T}_i\left(t\right)=SS{T}_i\left(t\right)=0$;   2: Initialize: $mTemp=null$;$isEffectDesc=true$;   3: Calculate ${\delta }_i$   4: for each $m\in Message{s}_i$ do   5:       if $mTemp==null$ then   6:             $mTemp=m$;   7:             Continue;   8:       end if   9:       if $C{E}_i(m,{\delta }_i)>C{E}_i(mTemp,{\delta }_i)$ then 10:             $isEffectDesc=false$; 11:             Break; 12:       else 13:             $mTemp=m$; 14:       end if 15: end for 16: for each $m\in Message{s}_i$ do 17:       if $!isEffectDesc$ then 18:             update $N{T}_i\left(t\right)$; 19:             $N{T}_i\left(t\right)={\displaystyle \frac{N{T}_i(t-\Delta t)+N{T}_i\left(t\right)}{2}}$; 20:       else if $isEffectDesc$ and $sr{c}_m==i$ then 21:             update $IS{T}_i\left(t\right)$; 22:             $IS{T}_i\left(t\right)={\displaystyle \frac{IS{T}_i(t-△t)+IS{T}_i\left(t\right)}{2}}$; 23:       else if $isEffectDesc$ and $sr{c}_m\ne i$ then 24:             update $SS{T}_i\left(t\right)$; 25:             $SS{T}_i\left(t\right)={\displaystyle \frac{SS{T}_i(t-\Delta t)+SS{T}_i\left(t\right)}{2}}$; 26:       end if 27: end for 28: return $N{T}_i\left(t\right)$, $IS{T}_i\left(t\right)$, $SS{T}_i\left(t\right)$

4.2.4. Node Social Trust Discrimination Rules

In the proposed node’s social trust detection mechanism, node i compares the updated normal trust $N{T}_i$, individually selfish trust $IS{T}_i$, and socially selfish trust $SS{T}_i$ obtained from Section 4.2.3 to determine its selfishness. The discrimination by this mechanism can be described in the following cases:

(1)

If $N{T}_i>IS{T}_i+SS{T}_i$, it indicates that node i has less probability of being a selfish node, excluding individual selfishness and social selfishness. It will continue to be judged more deeply through the message confirmation feedback detection (MCFD) mechanism.

(2)

If $IS{T}_i>N{T}_i$ and $IS{T}_i>SS{T}_i$, it indicates that node i is individually selfish and is marked as selfish. Otherwise, it proceeds to the judgment of rule (3).

(3)

If $SS{T}_i>N{T}_i$ and $SS{T}_i>IS{T}_i$, it indicates that node i is socially selfish and is marked as selfish. Otherwise, it continues to be judged more deeply through the message confirmation feedback detection (MCFD) mechanism.

In summary, the detailed detection steps of the node’s social trust detection (STD) mechanism are shown in Figure 4. The specific algorithmic process is shown in Algorithm 4.

Algorithm 4 STD Algorithm

Input:  $N{T}_i$, $IS{T}_i$, $SS{T}_i$ Output: Boolean value   1: if  $N{T}_i>IS{T}_i+SS{T}_i$  then   2:       Apply the MCFD algorithm to judge   3: else if  $IS{T}_i>N{T}_i$  and  $IS{T}_i>SS{T}_i$  then   4:       Boolean value = YES and i is an individually selfish node   5: else if  $SS{T}_i>N{T}_i$  and  $SS{T}_i>IS{T}_i$  then   6:       Boolean value = YES and i is a socially selfish node   7: end if

The figure above illustrates the algorithm used to identify selfish nodes within the STD, detailing the method to pinpoint such nodes via the mechanism that assesses their social trust. The algorithm requires inputs: $N{T}_i$, the standard trust of node i at time t; $IS{T}_i$, the trust related to individual selfishness of node i at time t; and $SS{T}_i$, the trust pertaining to social selfishness of node i at time t. The algorithm produces a Boolean outcome, with YES signifying a selfish node and NO indicating a non-selfish node. The assessment of whether node i is selfish is based on specific rules for evaluating node trust.

4.3. Message Confirmation Feedback Detection Mechanism (MCFD)

If neither SFWD nor STD detects selfish nodes, the message confirmation feedback detection (MCFD) mechanism is employed for conclusive determination. It scrutinizes whether nodes exhibit selfish behavior by examining confirmation feedback on message forwarding after message reception to ascertain if any message discarding occurs. In previous studies, monitoring of the node’s message-forwarding behavior typically employed the watchdog mechanism. However, the mobility and openness of SANs lead to unstable network topology, causing nodes to become uncontrollable regarding the direction of neighboring node movement and message transmission behavior, potentially resulting in nodes escaping monitoring and consequently causing misjudgments.

Therefore, through the MCFD, every node in the network keeps and updates encounter information with other nodes and also preserves and updates information on message-forwarding behavior. Subsequently, the exchange of encounter information between nodes is utilized to inspect for selfish message-discarding behavior. Nodes in the network maintain and update tables for the message-sending table MST, message reception table MRT, and node meeting table NMT. The message-sending table (MST) stores details of each sent message, m, including the sending time, $T^{send,m}$, receiving node address, and remaining message time-to-live, $TT{L}_{remain}^m$. The message reception table (MRT) retains information on each received message, m, and sending node address, while the encounter records table contains details of the addresses of two encountering nodes, their most recent encounter time, $T^{meet}$, and their remaining cache space, $B_{remain}$.

When node B receives a message, m, from node A and forwards it, corresponding entries are recorded in the respective tables. If node A encounters another node C after sending m, information in the shared tables is exchanged. Node B’s selfish behavior is determined as follows:

(1) If confirmation of the node reception of the message, m, forwarded by node B is found in node C’s message reception records table, $MR{T}_c$, indicating that node B successfully forwarded m after the reception, there is no discarding behavior, implying node B is not selfish.

(2) If there is no confirmation that node C received message m forwarded from node B from the node’s message reception records table $MR{T}_c$, then check the node meeting records table $NM{T}_c$ to see whether it met with node B. If an encounter does not occur, it suggests that node B did not come into contact with node C after receiving the message, m, and under these circumstances, it is not feasible to ascertain if node B exhibits selfish behavior. If an encounter did occur, this should be combined with node A’s message-sending records table, $MS{T}_a$, to check if the encounter time $T_{b,c}^{meet}$ between node B and node C is earlier than the time node A sent message m$T_a^{send,m}$. If so, it indicates that node B and node C had an encounter, and node B did not receive m from node A; at this time, we cannot judge whether node B is selfish or not. If not, then we check at this time if m’s remaining survival time $TT{L}_a^{remain}$ is less than the difference between node B and node C’s encounter $T_{b,c}^{meet}$, and the moment of node A sends the message $T_a^{send,m}$, or we see if node B’s remaining cache space $B_{remai{n}_b}$, which is less than the cache space required to forward the message of the minimum threshold $B_{min}$, is valid. If it is valid, it indicates that—at this time—the message m has expired, or node B discards the message due to the temporary cache shortage. At this time, it is not possible to judge whether node B is selfish or not; if it is not valid, then the difference between the moment of encounter between node B and C $T_{b,c}^{meet}$ and the moment node A sends message m $T_a^{send,m}$ is compared to the maximum time threshold $T_{max}$. This comparison is used to check whether node B received m and then took a very long period before encountering node C. If this is the case, it indicates a high likelihood that node B could forward m to other nodes, and at this time, it is still not possible to confirm if node B is selfish. If not, it indicates that node B encounters node C very soon after receiving the message m, and there is less probability that it will forward m to others. It denotes that node B receives m but drops it, indicating that the node is selfish.

To summarize, the algorithm for MCFD to detect the selfishness of nodes is shown in Algorithm 5. Algorithm inputs include the node’s message-sending records table, $MS{T}_a$, message reception records table $MR{T}_c$, nodes’ meeting records table $NM{T}_c$, minimum cache space threshold required for message forwarding $B_{min}$, and the encounter time threshold $T_{max}$. The output is a Boolean value (YES if node is selfish, NO if not).

Algorithm 5 MCFD algorithm

Input: $MS{T}_a$, $MR{T}_c$, $NM{T}_c$, $B_{min}$, $T_{max}$ Output: Boolean Value   1: if $m\in MR{T}_c$  then   2:       Boolean Value = NO   3: else if  $b\notin NM{T}_c$ then   4:       Boolean Value = NO   5: else if  $T_{b,c}^{meet}<T_a^{send,m}$ then   6:       Boolean Value = NO   7: else if  $TT{L}_{remain}^m<T_{b,c}^{meet}-T_a^{send,m}$ or  $B_{remai{n}_b}<B_{min}$ then   8:       Boolean Value = NO   9: else if  $T_{b,c}^{meet}-T_a^{send,m}>T_{max}$ then 10:       Boolean Value = NO 11: else 12:       Boolean Value = YES 13: end if

Figure 5 shows the detection steps of the message’s confirmation feedback detection mechanism MCFD. Then, the overall flowchart of the STCDA algorithm is shown in Figure 6.

5. Experimentation and Simulation

To evaluate the performance of the STCDA selfish node detection algorithm, which is based on social trust confirmation, we conducted simulation experiments on the ONE simulation platform [33] using an HP computer configured with a 1.90 GHz CPU, 16.0 GB of memory, and running Windows 10. Additionally, the spray-and-wait protocol [34] was used as the basis for data transmission in the experiments.

5.1. Simulation Parameters and Environment Settings

In the simulation experiments of STCDA presented in this paper, nodes represent individuals using mobile smartphones, with communication between these devices conducted via Bluetooth interface. The map used is the simulated map provided by the ONE simulation platform. Other relevant parameter settings for the simulation experiments are shown in

Table 1. Parameter settings for simulation experiments.

Parameter	Value
Simulation time	12 h
Number of nodes	180
Simulation area	4500 m × 3400 m
Transmit speed	250 kB/s
Transmit range	10 m
Movement model	ShortestPathMapBasedMovement
Routing protocol	Spray and Wait
Buffer size	10 M
Movement speed	0.5 m/s to 1.5 m/s
Message TTL	300 min
Message creation interval	25 s–35 s
Message Size	500 kB–1 MB
$\mu$	0.5

.

5.2. Simulation Scenarios and Performance Parameters

In the simulation experiments, the spray-and-wait routing algorithm was employed as the underlying network protocol. The STCDA algorithm was compared with the CCSDA algorithm from the literature [32] and the DSNDA algorithm [31] under varying proportions of selfish nodes, message survival times, and different message cache space sizes. Three simulation scenario schemes were designed as follows:

(1)

S+STCDA scheme: The network contains selfish nodes, and selfish behavior is identified using the STCDA detection method. The impacts of varying experimental conditions are analyzed by modifying experimental variables.

(2)

S+CCSDA scheme: The network includes some selfish nodes, identified using the CCSDA detection method. The effects are assessed by tweaking the experimental parameters as necessary.

(3)

S+DSNDA scheme: The presence of selfish nodes in the network is acknowledged, and their detection is facilitated by the DSNDA detection method. Observations of simulation outcomes are made by adaptively changing relevant experimental parameters.

This paper assesses network performance primarily by evaluating the efficacy and applicability of the incentive algorithm using two key metrics: message delivery rate and average delay.

Message delivery rate: This metric signifies the ratio of messages that are successfully delivered to their destinations out of the total messages generated, serving as a crucial measure of network efficiency.

Average latency: This represents the mean time taken for messages within the network to reach their intended recipients, indirectly indicating how efficiently network resources are utilized throughout the message transmission process.

5.3. Simulation Results and Performance Analysis

(1) Performance comparison and analysis of different algorithms under different proportions of selfish nodes.

For this simulation, the timeframe was set at 12 h, with the proportion of selfish nodes in the SANs designated at intervals of 20%, 40%, 60%, and 80%. The comparative performance of the three strategies, depicted in Figure 7 and Figure 8, focuses on the message delivery rate and the average delay in relation to the rising percentage of selfish nodes. The graphs clearly illustrate that, with an increase in selfish nodes, the STCDA algorithm not only enhances the message delivery rate but also maintains a reduced average delay, in contrast to the other two algorithms.

Figure 7 presents a comparative analysis of the message delivery rates across the three mentioned strategies. The graph clearly shows a decline in the message delivery rates for the STCDA, CCSDA, and DSNDA algorithms as the share of selfish nodes escalates. This decline is attributed to the ability of these algorithms to identify selfish nodes, resulting in the inability to forward messages through them during the message-forwarding process, and a decline in the number of successful message deliveries, which reduces the overall message delivery rate. Notably, the STCDA algorithm achieves a marginally higher message delivery rate compared to the other two. The message delivery rate of the STCDA algorithm is improved by 7.91% and 5.87% compared to DSNDA and CCSDA algorithms, respectively, at 80% of the selfish nodes. Within the S+DSNDA approach, the mechanism for assessing a node’s willingness to forward considers the node’s cache size as an indicator of its forwarding capability, thus influencing the determination of selfishness. However, since a node’s cache size fluctuates with message storage and forwarding activities, there may be instances where the cache is temporarily insufficient, potentially leading to inaccurate assessments. Conversely, the S+CCSDA scheme overlooks potential social selfishness among nodes and the inaccuracies of reputation assessments, which could result in incorrect or overlooked judgments.

Figure 8 provides a comparison of the average delays experienced by the three strategies under varying proportions of selfish nodes. The graph demonstrates that with a progressive increase in the share of selfish nodes, there is a corresponding rise in the average delays for the STCDA, CCSDA, and DSNDA algorithms. This trend occurs because the detection algorithm identifies and differentiates the selfish nodes in the network, and as the number of nodes available to facilitate message forwarding decreases, messages are not forwarded in time, resulting in increased average latency. The average delay of the S+STCDA scheme is obviously better than the other two schemes. At 80% of selfish nodes, the average delay percentages of the STCDA algorithm are reduced by 7.01% and 6.2% compared to the DSNDA and CCSDA algorithms, respectively. This is because the STCDA algorithm fully considers the social selfishness of nodes, precisely checks message confirmation discards, and also takes into account the node’s rejection rate for message reception to avoid misjudgments caused by temporary cache shortages, thereby preventing cooperative nodes from being classified as selfish nodes, leading to delayed message forwarding. The detection in S+DSNDA is also staged but does not account for nodes refusing to provide forwarding services due to temporary cache shortages. Moreover, its detection of message discards is not precise enough, leading to possible misjudgments. The S+CCSDA scheme overlooks the social selfishness of nodes and the inaccuracy of reputation assessments, resulting in a certain degree of misjudgment and omission, which affects network performance.

(2) Performance comparison and analysis of different algorithms under different message survival times.

When changing the message survival time, the percentage of selfish nodes was set to 70%, and the message survival times were set to 150, 200, 250, 300, 350, and 400 min. Figure 9 and Figure 10 describe the performance comparisons of these schemes by examining the message delivery rate and average delay as the message survival time varies. From the results of the simulation experiments, it is evident that with an increase in message survival time, the STCDA algorithm outperforms the other two algorithms. It not only improves the message delivery rate but also reduces the average delay.

Figure 9 showcases a comparison of the message delivery rates for the three strategies across various message lifespans. The graph illustrates an upward trend in the delivery rates for all three schemes as the message survival time extends. The enhancement in delivery rates can be attributed to the prolonged availability of messages within the network, providing greater opportunities for successful delivery to the intended recipients. At the same time, it is significant that the message delivery rate of the S+STCDA scheme gradually outperforms the two schemes using CCSDA and DSNDA algorithms because the STCDA algorithm fully considers the individual and social selfishness of nodes, introduces rejection rates for message reception to eliminate selfishness due to temporary cache shortages, and provides a more comprehensive judgment of selfish nodes. The STCDA algorithm improves by 7.47% and 2.71% in terms of the message delivery rate compared to the DSNDA and CCSDA algorithms, respectively, at a message TTL of 300 min. With the increase in message survival time, the STCDA algorithm can more accurately identify and bypass selfish nodes for message transmission, thereby improving the message delivery rate.

Figure 10 compares the average delays of the three schemes under different message survival times. The graph clearly indicates that with a gradual increase in the message survival time, the average delay experienced by the S+STCDA scheme is less than those of the S+CCSDA and S+DSNDA strategies. The STCDA algorithm reduces by 11.58% and 8.52% in terms of average latency compared to DSNDA and CCSDA algorithms, respectively, for a message TTL of 300 min. This is because the STCDA algorithm considers node energy and selfishness caused by temporary cache shortages, conducts detection of socially selfish nodes using the node’s social trust detection mechanism, and confirms message forwarding through shared information at node encounters, helping to quickly identify effective forwarding paths in message delivery, ensuring that messages are promptly delivered to the target nodes, and avoiding transmission delays caused by selfish nodes.

(3) Performance comparison and analysis of different algorithms under different buffer sizes.

We conducted a set of simulation experiments to check the effect of varying the node cache space size on the performance of the selfish node detection algorithm. Similarly, the percentage of selfish nodes in the network was set to 70% and the cache space sizes of the nodes were set to 4 M, 7 M, 10 M, 13 M, and 16 M.

Figure 11 presents the trend in message delivery rate for the three schemes S+STCDA, S+CCSDA, and S+DSNDA as the size of the cache space increases. The figure shows that the message delivery rate of all three algorithms increases with larger cache spaces because nodes with more cache can store additional messages that need to be forwarded, thereby prolonging the message lifecycle and reducing message blocking, which in turn improves the message delivery rate. Notably, the message delivery rate of the STCDA selfish node detection algorithm proposed in this paper outperforms the CCSDA and DSNDA algorithms. The STCDA algorithm improves the message delivery rate by 8.16% and 3.9% compared to the DSNDA and CCSDA algorithms, respectively, for a cache space size of 10 M. This improvement occurs because, with increasing cache space, the likelihood of individual selfish behavior due to limited cache becomes smaller. The STCDA algorithm fully considers social selfishness and reduces misjudgments, whereas the CCSDA and DSNDA algorithms do not account for the social selfishness of the nodes, resulting in their lower message delivery rates compared to the STCDA algorithm.

Figure 12 shows the trend of average latency for spray-and-wait routing algorithms using STCDA, CCSDA, and DSNDA selfish node detection algorithms in the presence of selfish nodes as the size of the cache space increases. The average latency of all three algorithms shows an overall increasing trend as the size of the cache space increases. This is because the increased storage capacity allows nodes to carry more messages, thus reaching the destination node faster. From the figure, it is clear that the STCDA algorithm proposed in this paper achieves the best performance in terms of average latency, significantly outperforming the other two algorithms. The STCDA algorithm reduces by 11.63% and 8.58% in terms of average latency compared to the DSNDA and CCSDA algorithms, respectively, for a cache space size of 10M. Similarly, the decrease in instances where a node is judged to be selfish due to insufficient cache space, following an increase in cache capacity, also contributes to this improvement. The SFWD mechanism in the STCDA algorithm, unlike the NFWM in the DSNDA, adequately considers the temporary insufficiency of cache space. In contrast, the CCSDA algorithm, despite using a mechanism similar to the NFWM in DSNDA, does not fully address temporary cache shortages. Moreover, the CCSDA algorithm fails to consider the social selfishness of nodes as effectively as the STCDA algorithm, leading to an incomplete exclusion of selfish nodes from the network and increased message blocking, so the latency generated by using the STCDA algorithm in the SANs is less than that of the other two algorithms.

6. Conclusions

As SANs has gained widespread attention, it can be applied in a variety of scenarios, but it still faces many challenges that require more in-depth research. The limited resources available for carrying and moving smart devices in SANs lead to the emergence of selfishness among nodes, which can be individually selfish due to limited resources, and socially selfish due to social preferences. The presence of selfish nodes can seriously affect network performance. Existing detection algorithms are temporarily insufficient due to the complexities of selfish behavior and node social selfishness, and the failure to accurately track and supervise the next-hop forwarding status and other issues leads to inaccurate identification of selfish nodes. To address these challenges, this paper proposes a selfish node detection algorithm based on social trust confirmation, namely STCDA. This STCDA algorithm comprises three main components: SFWD, STD, and MCFD. Initially, the SFWD mechanism is employed to determine selfish nodes based on two aspects: remaining node energy and the rejection rate of received messages. If the SFWD mechanism fails to detect selfishness, the STD mechanism is utilized to assess node selfishness based on the calculated social trust. If selfishness is still undetectable by STD, the MCFD mechanism is then employed to further examine the behavior of discarding messages through shared message-forwarding information exchanged during node encounters, thereby identifying the selfishness of nodes. The STCDA algorithm uses these three different mechanisms to determine the selfishness of the nodes in the SANs and will bypass these selfish nodes to transmit data to improve the network performance. Simulation experiment results validate the effectiveness of the STCDA algorithm. Under conditions of an 80% selfish node ratio, message TTL of 300 min, and 10 MB cache space, there are improvements of 7.91% and 5.87% in the message delivery rate and reductions of 7.01% and 6.2% in average latency compared to the DSNDA algorithm and CCSDA algorithm, respectively.

Although the proposed STCDA algorithm can effectively detect the selfish nodes in the network, it still has some problems and is not perfect enough. In the SFWD mechanism, the thresholds for a node’s energy and refusal to receive the message rate are set statically. A more reasonable dynamic threshold will be designed subsequently by combining the node’s relevant attributes, historical information, the surrounding environment, and other influencing factors, to improve the accuracy of detection.