Abstract:
The present invention relates to Group-based trust management scheme (GTMS) of wireless sensor networks. GTMS evaluates the trust of a group of sensor nodes in contrast to traditional trust management schemes that always focused on trust values of individual nodes. This approach gives us the benefit of requiring less memory to store trust records at each sensor node in the network. It uses the clustering attributes of wireless sensor networks that drastically reduce the cost associated with trust evaluation of distant nodes. Uniquely it provides not only a mechanism to detect malicious or faulty nodes, but also provides some degree of a prevention mechanism.

Description:
BACKGROUND OF THE INVENTION 
       [0001]    1. Field of the Invention 
         [0002]    The present invention relates to trust management for wireless sensor networks. 
         [0003]    2. Description of the Related Art 
         [0004]    Research work on trust management schemes for wireless sensor networks is in its infancy state. To our knowledge, very few trust management schemes for these types of networks have been proposed such as RFSN[S. Ganeriwal and M. B. Srivastava, “Reputation-based framework for high integrity sensor networks,”, in  Proc. Of ACM Security for Ad - hoc and Sensor Networks  ( SASN  2004), October 2004, pp. 66-67], ATRM[A. Boukerche, X. Li and K. EL-Khatib, “Trust-based security for wireless ad hoc and sensor networks,”  Computer Communications,  vol. 30, pp. 2413-2427, September 2007], and PLUS[Z. Yao, D. Kim, and Y. Doh, “PLUS:Parameterized and localized trust management scheme for sensor networks security,” in  Proc. Of the  3 rd    IEEE Int. Conf. on Mobile Ad - hoc and Sensor Systems  ( MASS  2006), Vancouver, Canada, October 2006, pp. 437-446]. Although, there are some other works available in the literature such as [K. Liu, N. Abu-Ghazaleh, and K.-D. Kang, “Location verification and trust management for resilient geographic routing,”  Journal of Parallel and Distributed Computing,  vol. 67, no. 2, pp. 215-228, 2007], [H. Chen, H. Wu, X. Zhou, and C. Gao, “Reputation-based trust in wireless sensor networks,” in  Proc. Of International conference on Multimedia and Ubiquitous Engineering  ( MUE&#39; 07), Korea, April 2007, pp. 603-607], that discuses trust but not in much great detail. 
         [0005]    In RFSN, each sensor node maintains the reputation for neighboring nodes only. Trust values are calculated on the basis of that reputation and it uses Bayesian formulation for representing reputation of a node. RFSN assumes that the node would have enough interactions with the neighbors so that the reputation (beta distribution) can reach a stationary state. However if the node mobility is at a higher rate, reputation information will not stabilize. In RFSN, nodes are classified into two categories: cooperative and not cooperative. In RFSN, no node is allowed to disseminate bad reputation information. If it is assumed that the “bad” reputation is implicitly included by not giving out good reputation then in that case, the scheme will not be able to cope with uncertainty situations. 
         [0006]    ATRM scheme is based on a clustered wireless sensor network and calculates trust in a fully distributed manner. ATRM assumes that there is a single trusted authority which is responsible for generating and launching mobile agents that make it vulnerable against a single point of failure. ATRM also assumes that mobile agents are resilient against malicious nodes that try to steal or modify information carried by the agent. In many applications this assumption may not be realistic. 
         [0007]    In PLUS scheme authors adopt a localized distributed approach and trust is calculated based on either direct observations or indirect observations. In this scheme, the authors assume that all the important control packets generated by the base station must contain a hashed sequence number(HSN). Inclusion of HSN in control packets not only increases the size of packets that results in higher consumption of transmission and reception power but also it increases the computational cost at the sensor nodes. Also, whenever a judge node receives a packet from another node i, it will always check the integrity of the packet. If the integrity check fails then the trust value of node i will be decreased irrespective of whether node i was really involved in making some modification in a packet maliciously or not. So node i may get unfair penalty. 
       SUMMARY OF THE INVENTION 
       [0008]    The present invention provides a new lightweight Group-based trust management scheme (GTMS) of wireless sensor networks. GTMS evaluates the trust of a group of sensor nodes in contrast to traditional trust management schemes that always focused on trust values of individual nodes. This approach gives us the benefit of requiring less memory to store trust records at each sensor node in the network. It uses the clustering attributes of wireless sensor networks that drastically reduce the cost associated with trust evaluation of distant nodes. Uniquely it provides not only a mechanism to detect malicious or faulty nodes, but also provides some degree of a prevention mechanism. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0009]    The above and other objects, features and other advantages of the present invention will be more clearly understood from the following detailed description taken in conjunction with the accompanying drawings, in which: 
           [0010]      FIG. 1  illustrate the sample scenario of the GTMS time window scheme according to an embodiment of the present invention. 
       
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
       [0011]    The present invention calculates the trust value based on direct or indirect observations. Direct observations represent the number of successful and unsuccessful interactions and indirect observations represent the recommendations of trusted peers about a specific node. 
         [0012]    Interaction means cooperation of two nodes. For example, a sender will consider interaction as a successful interaction if he got assurance that the packet is successfully received by the neighbor node and he has forwarded it toward destination in an unaltered fashion. 
         [0013]    First requirement of successful reception is achieved in reception of the link layer acknowledgment (ACK). IEEE 802.11 is a standard link layer protocol, which keeps packets in its cache until the sender received ACK. Whenever receiver node successfully received the packet he will send back ACK to the sender. If sender node did not received ACK during timeout then sender will retransmit that packet. 
         [0014]    Second requirement is achieved with the help of using enhanced passive acknowledgments (PACK) by overhearing the transmission of a next hop on the route, since they are within radio range[S. Buchegger and J.-Y. L. Boudec, “Self-policing mobile ad hoc networks by reputation systems,” IEEE  Communications Magazine,  vol. 43, no. 7, pp. 101-107, July 2005]. 
         [0015]    If the sender node does not overhear the retransmission of the packet within a timeout from its neighboring node or overhead packet is found to be illegally fabricated (by comparing the payload that is attached to the packet) then the sender node will consider that interaction as an unsuccessful one. If the number of unsuccessful interactions increases, then the sender node decreases the trust value of that neighboring node and may consider it as a faulty or malicious node. 
         [0016]    The trust model of the present invention is hybrid in nature, working with two topologies. One is the intra-group topology where distributed trust management is used. The other is inter-group topology where centralized trust management scheme is employed. For the intra-group network, each sensor that is a member of the group, calculates individual trust values for all group members. Based on the trust values, a node assigns one of the three possible states: 1) trusted, 2) un-trusted or 3) un-certain to other member nodes. This three-state solution is chosen for mathematical simplicity and found to provide the appropriate granularity to cover the situation. Then, each node forwards the trust state of all the group member nodes to the cluster-head. After that, centralized trust management takes over. Based on trust states of all group members, a cluster-head detects the malicious node(s) and forward a report to the base station. On request, each cluster-head also sends trust values of other cluster-heads to the base station. Once this information reaches the base station, it assigns one of the three possible states to the whole group. On request, the base station will forward the current state of a specific group to the cluster-heads. 
         [0017]    The group based trust model of the present invention works in three phases: 1) Trust calculation at the node level, 2) Trust calculation at the cluster-head level, and 3) Trust calculation at the base station level. 
         [0018]    1. Trust Calculation at the Node Level 
         [0019]    At the node level, a trust value is calculated using either time-based past interaction or peer recommendations. Whenever a node y wants to communicate with node x, it first checks whether y has any past experience of communication with x during a specific time interval or not. If yes, then node x makes a decision based on past interaction experience, and if not, then node x moves for the peer recommendation method. 
         [0020]    1) Time-Based Past Interaction Evaluation 
         [0021]    Trust calculation at each node measures the confidence in node reliability. Here the network traffic conditions such as conjunction, delay etc., should not affect the trust attached to a node; this means that the trust calculation should not emphasize the timing information of each interaction too rigidly. Therefore a sliding time window concept was introduced in the present invention which takes relative time into consideration and reduces the effects of network conditions on overall trust calculation. 
         [0022]    A timing window (Δt) is used to measure the number of successful and unsuccessful interactions. It consist of several timing units. The interactions in each time unit within the timing window that occur are recorded. After a unit of time elapses, the window slides one time unit to the right, thereby dropping the interactions done during the first unit. Thus, as time progresses, the window forgets the experiences of one unit but adds the experiences of the newer time unit. The window length could be made shorter or longer based on network analysis scenarios. A sample scenario of the GTMS time window scheme is illustrated in  FIG. 1 . 
         [0023]    With this time window information, the time-based past interaction trust value (T x,y ) of node y at node x that lies between 0 and 100, is defined as; 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           T 
                           
                             x 
                             , 
                             y 
                           
                         
                         = 
                         
                           [ 
                           
                             100 
                              
                             
                                 
                             
                              
                             
                               ( 
                               
                                 
                                   S 
                                   
                                     x 
                                     , 
                                     y 
                                   
                                 
                                 
                                   
                                     S 
                                     
                                       x 
                                       , 
                                       y 
                                     
                                   
                                   + 
                                   
                                     U 
                                     
                                       x 
                                       , 
                                       , 
                                       y 
                                     
                                   
                                 
                               
                               ) 
                             
                              
                             
                                 
                             
                              
                             
                               ( 
                               
                                 1 
                                 - 
                                 
                                   1 
                                   
                                     
                                       S 
                                       
                                         x 
                                         , 
                                         y 
                                       
                                     
                                     + 
                                     1 
                                   
                                 
                               
                               ) 
                             
                           
                           ] 
                         
                       
                     
                   
                   
                     
                       
                         = 
                         
                           [ 
                           
                             
                               100 
                                
                               
                                   
                               
                                
                               
                                 
                                   ( 
                                   
                                     S 
                                     
                                       x 
                                       , 
                                       y 
                                     
                                   
                                   ) 
                                 
                                 2 
                               
                             
                             
                               
                                 ( 
                                 
                                   
                                     S 
                                     
                                       x 
                                       , 
                                       y 
                                     
                                   
                                   + 
                                   
                                     U 
                                     
                                       x 
                                       , 
                                       y 
                                     
                                   
                                 
                                 ) 
                               
                                
                               
                                   
                               
                                
                               
                                 ( 
                                 
                                   
                                     S 
                                     
                                       x 
                                       , 
                                       y 
                                     
                                   
                                   + 
                                   1 
                                 
                                 ) 
                               
                             
                           
                           ] 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where [.] is the nearest integer function, S x,y  is the total number of successful interactions of node x with y during Δt time, U x,y  is the total number of unsuccessful interactions of node x with y during time Δt. The expression 
         [0000]    
       
         
           
             ( 
             
               1 
               - 
               
                 1 
                 
                   
                     S 
                     
                       x 
                       , 
                       y 
                     
                   
                   + 
                   1 
                 
               
             
             ) 
           
         
       
     
         [0000]    in the above approaches 1 rapidly with an increase in the number of successful interactions. We choose this function instead of a linear function since such a function would approach very slowly to 1 with the increase in successful interactions; hence it would take a considerably long time for a node to increase its trust value for another node. In order to balance this increase in the trust value with the increasing number of unsuccessful interactions, we multiply the expression with factor 
         [0000]    
       
         
           
             
               ( 
               
                 
                   S 
                   
                     x 
                     , 
                     y 
                   
                 
                 
                   
                     S 
                     
                       x 
                       , 
                       y 
                     
                   
                   + 
                   
                     U 
                     
                       x 
                       , 
                       y 
                     
                   
                 
               
               ) 
             
             , 
           
         
       
     
         [0000]    which indicates the percentage of successful interactions among the total interactions. 
         [0024]    After calculating trust values, a node will quantize it into three states as follows: 
         [0000]    
       
         
           
             
               
                 
                   
                     Mp 
                      
                     
                       ( 
                       
                         T 
                         
                           x 
                           , 
                           y 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           trusted 
                         
                         
                           
                             
                               100 
                               - 
                               f 
                             
                             ≤ 
                             
                               T 
                               
                                 x 
                                 , 
                                 y 
                               
                             
                             ≤ 
                             100 
                           
                         
                       
                       
                         
                           uncertain 
                         
                         
                           
                             
                               50 
                               - 
                               g 
                             
                             ≤ 
                             
                               T 
                               
                                 x 
                                 , 
                                 y 
                               
                             
                             &lt; 
                             
                               100 
                               - 
                               f 
                             
                           
                         
                       
                       
                         
                           untrusted 
                         
                         
                           
                             0 
                             ≤ 
                             
                               T 
                               
                                 x 
                                 , 
                                 y 
                               
                             
                             &lt; 
                             
                               50 
                               - 
                               g 
                             
                           
                         
                       
                     
                     } 
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where, f represents the half of the average values of all trusted nodes and g represents the one third of the average values of all untrusted nodes. Both f and g are calculated as follows: 
         [0000]    
       
         
           
             
               
                 
                   
                     f 
                     
                       j 
                       + 
                       1 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             [ 
                             
                               
                                 1 
                                 2 
                               
                                
                               
                                 ( 
                                 
                                   
                                     
                                       ∑ 
                                       
                                         i 
                                         ∈ 
                                         
                                           R 
                                           x 
                                         
                                       
                                     
                                      
                                     
                                         
                                     
                                      
                                     
                                       T 
                                       
                                         x 
                                         , 
                                         i 
                                       
                                     
                                   
                                   
                                      
                                     
                                       R 
                                       x 
                                     
                                      
                                   
                                 
                                 ) 
                               
                             
                             ] 
                           
                         
                         
                           
                             0 
                             &lt; 
                             
                                
                               
                                 R 
                                 x 
                               
                                
                             
                             ≤ 
                             
                               n 
                               - 
                               1 
                             
                           
                         
                       
                       
                         
                           
                             f 
                             j 
                           
                         
                         
                           
                             
                                
                               
                                 R 
                                 x 
                               
                                
                             
                             = 
                             0 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
             
               
                 
                   
                     g 
                     
                       j 
                       + 
                       1 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             [ 
                             
                               
                                 1 
                                 3 
                               
                                
                               
                                 ( 
                                 
                                   
                                     
                                       ∑ 
                                       
                                         i 
                                         ∈ 
                                         
                                           M 
                                           x 
                                         
                                       
                                     
                                      
                                     
                                         
                                     
                                      
                                     
                                       T 
                                       
                                         x 
                                         , 
                                         i 
                                       
                                     
                                   
                                   
                                      
                                     
                                       M 
                                       x 
                                     
                                      
                                   
                                 
                                 ) 
                               
                             
                             ] 
                           
                         
                         
                           
                             0 
                             &lt; 
                             
                                
                               
                                 M 
                                 x 
                               
                                
                             
                             ≤ 
                             
                               n 
                               - 
                               1 
                             
                           
                         
                       
                       
                         
                           
                             g 
                             j 
                           
                         
                         
                           
                             
                                
                               
                                 M 
                                 x 
                               
                                
                             
                             = 
                             0 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where [.] is the nearest integer function, R x  represents the set of trustful nodes for node x, M x  the set of untrustful nodes for node x, and n is the total number of nodes that contains trustful, un-trustful and uncertain nodes. At startup, the trust values of all nodes are 50 which is an uncertain state. Initially, f and g are equal to 25 and 17 respectively, although other values could also be used by keeping following constraint intact: f i −g i ≧1, which is necessary for keeping an uncertain zone between a trusted and un-trusted zone. 
         [0025]    The values of f, and g are adaptive. During the steady-state operation, these values can change with every passing unit of time that create dynamic trust boundaries. At any stage when |R x | or |M x | becomes zero then the values of f j+1  or g j+1  remain the same as the previous values (f j  and g j ). The nodes whose value is above 100−f will be declared as trustful nodes (Eq. 2), and nodes whose value is lower than 50−g will be consider as an untrusted node (Eq. 2). After each passage of Δt, nodes will recalculate the values of f and g. This trust calculation procedure will continue in this fashion. 
         [0026]    2) Peer Recommendations Evaluation 
         [0027]    Let a group be composed of n uniquely identified nodes. Futhermore, each node maintains a trust value for all other nodes. Whenever a node requires peer recommendation it will send request to all member nodes except the un-trusted ones. Let us assume that j nodes are trusted and uncertain in a group. Then node x calculates the trust value of node y as follows: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         T 
                         
                           x 
                           , 
                           y 
                         
                       
                       = 
                       
                         [ 
                         
                           
                             
                               ∑ 
                               
                                 i 
                                 ∈ 
                                 
                                   
                                     R 
                                     x 
                                   
                                   ⋃ 
                                   
                                     C 
                                     x 
                                   
                                 
                               
                             
                              
                             
                                 
                             
                              
                             
                               
                                 T 
                                 
                                   x 
                                   , 
                                   i 
                                 
                               
                               * 
                               
                                 T 
                                 
                                   i 
                                   , 
                                   y 
                                 
                               
                             
                           
                           
                             100 
                             * 
                             j 
                           
                         
                         ] 
                       
                     
                     ; 
                   
                    
                   
                     
 
                   
                    
                   
                     j 
                     = 
                     
                       
                          
                         
                           
                             R 
                             x 
                           
                           ⋃ 
                           
                             C 
                             x 
                           
                         
                          
                       
                       ≤ 
                       
                         n 
                         - 
                         2 
                       
                     
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where, [.] is the nearest integer function, T x,i  is the trust value of recommender, and T i,y  is the trust value of node y sent by node i. Here T x,i  is acting as a weight value of the recommender that is multiplied with the trust value T i,y , send by recommender, such that the trust value of node y should not increase beyond the trust value between node x and the recommender node i. 
         [0028]    2. Trust Calculation at the Cluster-Head Level 
         [0029]    Here we assume that the cluster-head is the sensor node that has higher computational power and memory as compared to other sensor nodes. 
         [0030]    1) Trust State Calculation of Own Group 
         [0031]    In order to calculate the global trust value of nodes in a group, cluster-head ask the nodes for their trust states of the other members in the group. We use the trust states instead of the exact trust values due to two reasons. First, the communication overhead would be less as only a simple state is to be forwarded to the cluster-head. Secondly, the trust boundaries of an individual node vary from other nodes. A particular trust value might be in a trusted zone for one node whereas it may only correspond to the uncertain zone for another node. Hence the calculation of the global trust state of nodes in a group would be more feasible and efficient if we only calculate it using the trust states. 
         [0032]    Let us suppose there are n+1 nodes in the group including the cluster-head. The cluster-head will periodically broadcast the request packet within the group. In response, all group member nodes forward their trust states, s, of other member nodes to the cluster-head. The variable, s, can take three possible states: trusted, un-certain and un-trusted. The cluster-head will maintain these trust states in a matrix form, as shown below: 
         [0000]    
       
         
           
             
               
                 
                   
                     TM 
                     ch 
                   
                   = 
                   
                     [ 
                     
                       
                         
                           
                             s 
                             
                               ch 
                               , 
                               1 
                             
                           
                         
                         
                           
                             s 
                             
                               1 
                               , 
                               ch 
                             
                           
                         
                         
                           … 
                         
                         
                           
                             s 
                             
                               n 
                               , 
                               1 
                             
                           
                         
                       
                       
                         
                           
                             s 
                             
                               ch 
                               , 
                               2 
                             
                           
                         
                         
                           
                             s 
                             
                               1 
                               , 
                               2 
                             
                           
                         
                         
                           … 
                         
                         
                           
                             s 
                             
                               n 
                               , 
                               2 
                             
                           
                         
                       
                       
                         
                           ⋮ 
                         
                         
                           ⋮ 
                         
                         
                           ⋮ 
                         
                         
                           ⋮ 
                         
                       
                       
                         
                           
                             s 
                             
                               ch 
                               , 
                               n 
                             
                           
                         
                         
                           
                             s 
                             
                               1 
                               , 
                               n 
                             
                           
                         
                         
                           … 
                         
                         
                           
                             s 
                             
                               n 
                               , 
                               
                                 n 
                                 - 
                                 1 
                               
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where, TM ch  represents the trust state matrix of cluster-head ch and s ch,1  represents the state of node 1 at cluster-head ch. The cluster-head assigns a global trust state to a node based on the relative difference in trust states for that node. We emulate this relative difference through a standard normal distribution. Therefore, the cluster-head will define a random variable X such that: 
         [0000]    
       
         
           
             
               
                 
                   
                     X 
                      
                     
                       ( 
                       
                         s 
                         
                           i 
                           , 
                           j 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           2 
                         
                         
                           when 
                         
                         
                           
                             
                               s 
                               
                                 i 
                                 , 
                                 j 
                               
                             
                             = 
                             trusted 
                           
                         
                       
                       
                         
                           1 
                         
                         
                           when 
                         
                         
                           
                             
                               s 
                               
                                 i 
                                 , 
                                 j 
                               
                             
                             = 
                             
                               un 
                                
                               
                                 - 
                               
                                
                               certain 
                             
                           
                         
                       
                       
                         
                           0 
                         
                         
                           when 
                         
                         
                           
                             
                               s 
                               
                                 i 
                                 , 
                                 j 
                               
                             
                             = 
                             
                               un 
                                
                               
                                 - 
                               
                                
                               trusted 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
           
         
       
     
         [0033]    Assuming this to be a uniform random variable, we define the sum of m such random variables as S m . The behavior of S m  will be that of a normal variable due to central-limit theorem [H. Tijms,  Understanding Probabililty: Chance Rules in Everyday Life.  Cambrideg: Cambridge University Press, 2004]. The expected value of this random variable is m and the standard deviation is √m/3. The cluster-head defines the following standard normal random variable for a node j: 
         [0000]    
       
         
           
             
               
                 
                   
                     Z 
                     j 
                   
                   = 
                   
                     
                       
                         3 
                       
                        
                       
                         ( 
                         
                           
                             X 
                              
                             
                               ( 
                               
                                 s 
                                 
                                   ch 
                                   , 
                                   j 
                                 
                               
                               ) 
                             
                           
                           + 
                           
                             
                               ∑ 
                               
                                 
                                   i 
                                   = 
                                   1 
                                 
                                 , 
                                 
                                   i 
                                   ≠ 
                                   j 
                                 
                               
                               m 
                             
                              
                             
                                 
                             
                              
                             
                               X 
                                
                               
                                 ( 
                                 
                                   s 
                                   
                                     i 
                                     , 
                                     j 
                                   
                                 
                                 ) 
                               
                             
                           
                           - 
                           m 
                         
                         ) 
                       
                     
                     
                       m 
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
         [0034]    If Z j  □[−1, 1] then the node j is termed un-certain, else if Z j &gt;1, it is called trusted. If Z j &lt;−1, it is labeled as un-trusted. 
         [0035]    2) Trust Calculation of Other Groups 
         [0036]    During group-to-group communications, the cluster-head maintain the record of past interactions of another group in the same manner as individual nodes keep record of other nodes. Trust values of a group is calculated on the basis of either past interaction or information passed on by the base station. Here we are nor considering peer recommendations from other groups in order to save transmission and reception power of cluster head node. Let us suppose cluster head i wants to calculate the trust value (T i,j ) of another cluster j, then it can be calculated by using either time-based past interaction(PI i,j ) evaluation or by getting recommendation from base station (BR i,j ) as shown below. 
         [0000]    
       
         
           
             
               
                 
                   
                     T 
                     
                       i 
                       , 
                       j 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             [ 
                             
                               
                                 100 
                                  
                                 
                                   
                                     ( 
                                     
                                       S 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                     
                                     ) 
                                   
                                   2 
                                 
                               
                               
                                 
                                   ( 
                                   
                                     
                                       S 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                     
                                     - 
                                     
                                       U 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                     
                                   
                                   ) 
                                 
                                  
                                 
                                   ( 
                                   
                                     
                                       S 
                                       
                                         i 
                                         , 
                                         j 
                                       
                                     
                                     + 
                                     1 
                                   
                                   ) 
                                 
                               
                             
                             ] 
                           
                         
                         
                           
                             
                               if 
                                
                               
                                   
                               
                                
                               
                                 PI 
                                 
                                   i 
                                   , 
                                   j 
                                 
                               
                             
                             ≠ 
                             ϕ 
                           
                         
                       
                       
                         
                           
                             BR 
                             
                               i 
                               , 
                               j 
                             
                           
                         
                         
                           
                             
                               if 
                                
                               
                                   
                               
                                
                               
                                 PI 
                                 
                                   i 
                                   , 
                                   j 
                                 
                               
                             
                             = 
                             ϕ 
                           
                         
                       
                     
                     } 
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
         [0037]    If the cluster head does not have any record of past interactions within the time window means PI i,j =φ, then, it requests the base station for the trust value. 
         [0038]    3. Trust Calculation at Base Station Level 
         [0039]    The base station also maintains the record of past interaction with cluster-heads in the same manner as individual nodes do as shown below. 
         [0000]    
       
         
           
             
               
                 
                   
                     T 
                     
                       BS 
                       , 
                       
                         ch 
                         i 
                       
                     
                   
                   = 
                   
                     [ 
                     
                       
                         100 
                          
                         
                             
                         
                          
                         
                           
                             ( 
                             
                               S 
                               
                                 BS 
                                 , 
                                 
                                   ch 
                                   i 
                                 
                               
                             
                             ) 
                           
                           2 
                         
                       
                       
                         
                           ( 
                           
                             
                               S 
                               
                                 BS 
                                 , 
                                 
                                   ch 
                                   i 
                                 
                               
                             
                             - 
                             
                               U 
                               
                                 BS 
                                 , 
                                 
                                   ch 
                                   i 
                                 
                               
                             
                           
                           ) 
                         
                          
                         
                             
                         
                          
                         
                           ( 
                           
                             
                               S 
                               
                                 BS 
                                 , 
                                 
                                   ch 
                                   i 
                                 
                               
                             
                             + 
                             1 
                           
                           ) 
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where [.] is the nearest integer function, S BS,ch  is the total number of successful interactions of base station with cluster-head during Δt time, U BS,ch  is the total number of unseccessful interactions of base station with cluster-head during time Δt. 
         [0040]    Let us suppose there are |G| groups in the network. Base station periodically multicast request packets to the cluster-heads. On request, the cluster-heads forward their trust vector related to the recommendations of other groups based upon past interactions to base station as shown below. 
         [0000]          T     ch =( T   ch,1   ,T   ch,2   , . . . ,T   ch,|G|−1 )   (11) 
         [0041]    On reception of trust vectors form all the cluster-heads, the base station will calculate the trust value of each group in manner shown below 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       T 
                       
                         BS 
                         , 
                         
                           G 
                           1 
                         
                       
                     
                     = 
                     
                       [ 
                       
                         
                           
                             ∑ 
                             
                               i 
                               = 
                               1 
                             
                             
                               
                                  
                                 G 
                                  
                               
                               - 
                               1 
                             
                           
                            
                           
                               
                           
                            
                           
                             
                               ( 
                               
                                 T 
                                 
                                   BS 
                                   , 
                                   
                                     ch 
                                     i 
                                   
                                 
                               
                               ) 
                             
                              
                             
                               ( 
                               
                                 T 
                                 
                                   
                                     G 
                                     i 
                                   
                                   , 
                                   
                                     G 
                                     1 
                                   
                                 
                               
                               ) 
                             
                           
                         
                         
                           
                              
                             G 
                              
                           
                           - 
                           1 
                         
                       
                       ] 
                     
                   
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   
                     
 
                   
                    
                   
                     
                       T 
                       
                         BS 
                         , 
                         
                           G 
                           m 
                         
                       
                     
                     = 
                     
                       [ 
                       
                         
                           
                             ∑ 
                             
                               i 
                               = 
                               1 
                             
                             
                               
                                  
                                 G 
                                  
                               
                               - 
                               1 
                             
                           
                            
                           
                               
                           
                            
                           
                             
                               ( 
                               
                                 T 
                                 
                                   BS 
                                   , 
                                   
                                     ch 
                                     i 
                                   
                                 
                               
                               ) 
                             
                              
                             
                               ( 
                               
                                 T 
                                 
                                   
                                     G 
                                     i 
                                   
                                   , 
                                   
                                     G 
                                     
                                        
                                       G 
                                        
                                     
                                   
                                 
                               
                               ) 
                             
                           
                         
                         
                           
                              
                             G 
                              
                           
                           - 
                           1 
                         
                       
                       ] 
                     
                   
                 
               
               
                 
                   ( 
                   12 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where [.] is the nearest integer function, T BS,chi  is the trust value of the cluster-head i at the base station, T Gi,G1  is the trust value of group G 1  at group G i  and |G| represents the number of groups in the network.