# Trusted Energy-Aware Hierarchical Routing (TEAHR) for Wireless Sensor Networks
## 2 Related Studies
### Problem with Existing Schemes  
Trust-based algorithms have many inherent problems that can impact their performance, trustworthiness, and overall effectiveness. While various trust models have been proposed for Wireless Sensor Networks (WSNs), they suffer from inherent limitations that impact their performance and trustworthiness. Key limitations include poor scalability in large networks, high energy overhead on tiny battery-powered nodes, susceptibility to certain malicious tactics, and inflexibility in dynamic environments. Limited scalability is a major shortcoming of many early trust models. As WSN deployments grow to hundreds or thousands of nodes, the overhead of maintaining and exchanging trust information explodes. Each node may need to monitor and store trust values for numerous neighbors and broadcast updates, which does not scale well. In large networks, this can **saturate communication channels and memory**, slowing down the whole system. Authors [32] note that a WSN with a \"large number of sensor nodes\" requires a **scalable algorithm** for trust management, prompting the use of clustering to handle many nodes efficiently. In flat (non-hierarchical) trust schemes, adding more nodes exponentially increases messages and computations, making them impractical beyond small network sizes. A specific failure example is a simulated 1000-node WSN using a flat trust table is as follows: the trust update traffic overwhelmed the network, delaying data delivery and even causing packet losses due to congestion (an implicit **scalability issue** that motivated hierarchical trust protocols). In summary, conventional models often **do not scale**--they may work in testbeds of 20 or 50 nodes but start to break down in large-scale deployments because of communication overhead and centralization bottlenecks. WSN nodes are **severely energy-constrained**, typically running on small batteries with limited capacity. A robust trust mechanism must be lightweight; otherwise, the energy cost of continuous monitoring and trust computation can shorten node lifespan dramatically. Many existing trust models did not fully account  
Figure 3: Routing protocols in WSN [27; 28]. for this, leading to high energy drain. The **resource constraints (power, memory, CPU)** of sensors are \"one of the most challenging barriers\" in designing trust systems [10]. Frequent trust updates (e.g., broadcasting recommendations or heartbeats) and complex calculations (like Bayesian updates or cryptographic validations) consume extra energy on top of normal sensing duties. For instance, a node that must perform intensive trust calculations for every packet will use more CPU and radio time, accelerating its battery depletion. Beyond performance issues, many trust models are vulnerable to **sophisticated attacks** where malicious nodes exploit the trust system itself. Three notorious attack strategies in WSNs are **Sybil attacks, bad-mouthing attacks**, and **on-off (selective misbehavior) attacks**. In a Sybil attack, a single adversary forges many fake identities (pretending to be multiple distinct sensor nodes). WSNs frequently experience node join/leave events (due to node failures and deployments), so an attacker introducing new Sybil nodes \"appears as new nodes\" and is hard to immediately distinguish from legitimate joins [33]. Bad-mouthing (also called slander) involves malicious collusion to **spread false negative reputations** about honest nodes. In a reputation-based trust system, nodes often rely on peer recommendations; a group of compromised nodes can exploit this by all reporting a target node as untrustworthy (even if it behaved correctly). An experiment comparing trust frameworks showed that a model without strong collusion defense (referred to as LDTS) performed poorly against bad-mouthing--it was rated \"Low\" in security against such attacks [10]. In an on-off attack, a malicious node alternates between good behavior and bad behavior in cycles.