Trustworthiness in Resource-Constrained IoT: Review and Taxonomy of Privacy-Enhancing Technologies and Anomaly Detection

Abstract

Resource-constrained Internet of Things (IoT) devices are increasingly deployed in critical domains but remain vulnerable to stealthy attacks that can bypass conventional defenses. At the same time, privacy constraints limit centralized data collection and processing, complicating anomaly detection. This systematic review surveys methods for privacy-preserving anomaly detection in resource-constrained IoT and introduces a five-dimension taxonomy covering deployment paradigms, resource constraints, real-time requirements, protection techniques, and communication constraints. We review how the literature measures and reports resource and privacy costs and identify three major gaps: (1) a shortage of co-designed detector-plus-privacy solutions tailored to constrained hardware, (2) inconsistent reporting of resource and privacy trade-offs, and (3) limited robustness against adaptive attackers and realistic deployment noise. We conclude with actionable recommendations and a prioritized research roadmap. Furthermore, the multi-dimensional taxonomy we introduce provides a structured framework to guide design choices and systematically improve the comparability, deployability, and overall trustworthiness of anomaly detection systems for constrained IoT.

1. Introduction

The Internet of Things (IoT) has reshaped many industries by enabling ubiquitous connectivity and autonomous data sharing [1,2]. Across domains—from remote health monitoring to automated manufacturing—IoT solutions hold considerable promise for improving operational efficiency and quality of life [3,4,5]. At the same time, this growth creates serious security concerns, especially for the resource-limited devices that underpin most IoT deployments [6,7]. The rapid uptake of IoT has therefore driven research into privacy-preserving methods such as lightweight cryptography, federated learning, and differential privacy [8,9]. Nonetheless, protecting constrained environments remains challenging and requires holistic strategies that balance data confidentiality, user privacy, and robust anomaly detection [10].

IoT trustworthiness refers to the justified confidence in a system’s ability to deliver its intended service while maintaining critical properties throughout its operational lifecycle [11]. This concept comprises several interdependent pillars: security (confidentiality, integrity, and availability), privacy, safety, reliability, and resilience. Frameworks like zero-trust explicitly operationalize these pillars through principles such as least-privilege access, continuous verification, and data confidentiality by design [10]. Confidentiality restricts data access to authorized parties; integrity protects data and systems from unauthorized modification; and availability ensures timely, dependable access to services and information. Authenticity—verifying device identities and data provenance—underpins both integrity and confidentiality. Privacy guarantees that personal and sensitive information is managed according to applicable policies and regulations (e.g., GDPR and CCPA) and fundamentally depends on security controls such as confidentiality. Safety denotes the absence of unacceptable physical-harm risks, which can be undermined by breaches of security (for example, integrity failures). Reliability is the capability to perform required functions under specified conditions and relies on sustained integrity and availability. Resilience denotes the capacity to withstand, adapt to, and recover from disruptions—an advanced expression of reliability and availability, especially under adversarial conditions. These properties appear at device/node, data, and system levels, together forming a comprehensive trust model for IoT environments.

Resource-constrained devices—typically class 0/1 with strict limits on CPU, memory, and energy [12]—are widespread in IoT deployments and introduce distinct security challenges. Their limited resources demand tailored solutions that carefully trade off protection and cost [13], as seen in adaptations of federated learning and cryptographic protocols for heterogeneous IoT networks [9]. Even though edge/fog devices (class 2) provide greater capability, they remain far more constrained than cloud infrastructure and therefore require security mechanisms optimized for limited environments.

This review argues that achieving robust IoT trustworthiness requires combining privacy-enhancing technologies (PETs) with anomaly detection (AD). PETs deliver preventive protection via cryptographic and privacy-preserving controls, while AD supplies reactive, behavior-based monitoring. Together they form complementary defense layers: PETs preserve the integrity and confidentiality of data that AD relies on, and AD can reveal threats that evade cryptographic boundaries. This integrated strategy is recognized as crucial for next-generation secure IoT, aligning with paradigms that fuse federated learning with behavioral analytics [9] and embed zero-trust principles [10]. Consequently, it helps mitigate the enlarged attack surface and the evolving adversary tactics documented in recent IoT threat reports [14,15,16].

Our work advances the field through three key contributions:

• A novel multi-dimensional taxonomy for IoT anomaly detection (Section 4) addressing deployment paradigms, resource constraints, real-time requirements, protection techniques, and communication constraints.
• A critical review of hybrid security frameworks integrating lightweight cryptography with distributed intelligence for constrained environments.
• Actionable mitigation strategies derived from real-world breach analysis, providing practical guidance for industry practitioners.

Our review contributes two practical things. First, we present a clear taxonomy and gap analysis that help guide research into resource-efficient security designs, particularly for hybrid frameworks and modern cryptography. Second, we translate those findings into tangible recommendations for industry practitioners—for example, better edge–AI integration, clearer standards, and mitigation strategies drawn from real breaches to improve resilience against evolving threats. As IoT moves into high-stakes domains like smart energy grids and elderly-care monitoring, this work gives researchers and practitioners scalable, trustworthy approaches they can actually apply.

This review progresses as follows: Section 2 outlines the methodology; Section 3 analyzes IoT security foundations, constraints, and core techniques; Section 4 presents our anomaly detection taxonomy and its application; Section 5 discusses the integrated implications and core tensions; Section 6 identifies future research directions; and Section 7 concludes this study.

2. Methodology

This review adapted the PRISMA 2020 guidelines [17] to ensure methodological transparency and reproducibility. The approach comprised four phases: search strategy, screening and selection, quality assessment, and data synthesis.

Systematic queries were executed across six academic databases (IEEE Xplore, ACM Digital Library, SpringerLink, ScienceDirect, Scopus, and Web of Science) using the following Boolean search string:

(“Internet of Things” OR IoT) AND (“security” OR “privacy”) AND (“anomaly detection” OR “lightweight cryptography”) AND (“resource-constrained devices”)

While the search used “lightweight cryptography” as a key term, subsequent screening actively included studies on broader privacy-enhancing technologies (PETs), such as federated learning and differential privacy. The initial search yielded 2427 records (January 2025).

Studies were filtered using explicit inclusion/exclusion criteria (

Table 1. Inclusion and exclusion criteria.

Criterion	Inclusion	Exclusion
Language	English	Non-English publications
Time Frame	January 2015–January 2025	Studies outside this period
Publication Type	Peer-reviewed journals and conference proceedings	Books, editorials, and patents
Device Focus	Resource-constrained IoT devices	Non-constrained systems
Technical Scope	Lightweight security, privacy preservation, or anomaly detection	General cybersecurity without IoT focus
Validation	Empirical validation (simulation or testbed)	Theoretical-only frameworks

), focusing on resource-constrained IoT devices (class 0/1 per [12]) with empirical validation. After removing 292 records failing basic criteria and 1051 duplicates, 1084 studies underwent title/abstract screening. We conducted a full-text review of 571 studies and performed a structured, qualitative appraisal. This appraisal assessed the robustness of empirical studies by considering factors such as experimental validity (including sample size and dataset characteristics), reproducibility of methods, transparency of reported performance metrics, IoT context relevance, and comparative analysis of evaluation practices. Studies that provided sufficient methodological detail and reported results in the context of class 0/1 device constraints were prioritized in our synthesis. Ultimately, 97 studies qualified for synthesis.

The synthesis of findings was necessarily qualitative rather than quantitative. The high heterogeneity across studies—in hardware platforms, evaluation metrics, experimental conditions, and reporting formats—precluded a formal meta-analysis or the application of a unified scoring rubric. Instead, we focused on identifying common themes, design patterns, and research gaps through a structured comparative analysis, which is organized within the framework of our taxonomy (Section 4) and supported by comparative tables presented in later sections, along with the Supplementary Tables S1–S4.

We acknowledge that excluding non-English publications may introduce language bias and affect the review’s comprehensiveness, given IoT’s global research landscape. While we mitigated this by scanning reference lists of key reviews for prominent non-English works, our synthesis primarily reflects the English-language literature. This limitation should be considered when interpreting the findings.

The included studies were systematically classified into three thematic categories aligned with our research objectives: (1) inherent security constraints and real-world breaches; (2) privacy-preserving techniques and lightweight cryptography; and (3) anomaly detection methodologies optimized for constrained environments.

3. IoT Security Foundations: Constraints and Core Techniques

Resource-constrained IoT devices face particular security challenges that originate from fundamental hardware limitations, trust management complexities, and systemic architectural vulnerabilities. This section analyzes these core constraints and their implications for implementing effective security measures in constrained environments, establishing the foundation for understanding why specialized privacy-enhancing and anomaly detection approaches are necessary.

3.1. Security Limitations in Resource-Constrained IoT

3.1.1. Hardware and Computational Constraints

Resource-constrained IoT devices (RFC 7228 classes 0 and 1 [12]) operate under strict CPU, memory, and energy budgets that fundamentally dictate feasible security mechanisms. Typical devices in these classes are built around sub-100 MHz microcontrollers, often with less than 50 KB of RAM and 100 KB of flash storage, and are frequently powered by batteries or energy harvesting. These limitations have direct consequences: (1) computationally intensive cryptographic operations significantly increase latency and energy consumption; (2) scarce memory prevents large buffering or complex stateful protocols; and (3) stringent energy budgets force a trade-off between core functions (e.g., sensing) and security operations (e.g., authentication and secure over-the-air updates). In continuous operation, security mechanisms can consume up to 60% of the total power budget [18], making this trade-off critical.

These constraints impede the use of full protocol stacks and standard security libraries. Consequently, node software is designed for minimal code size and runtime memory at the expense of extensibility and comprehensive security [19]. The resulting processing limitations severely degrade cryptographic implementations. The absence of hardware crypto-accelerators, a common cost-saving measure, forces inefficient software-based execution (e.g., of AES) that drastically reduces system performance and responsiveness [20]. While studies like that of Lachner et al. [21] demonstrate performance variation across hardware, they often overlook energy costs—a critical oversight for IoT. This often forces the adoption of compressed protocol variants or the delegation of complex functions, such as asymmetric cryptography, to nearby gateways or edge proxies [22].

Limited RAM and persistent storage severely restrict cryptographic choices and key management on class 0/1 devices. These devices often cannot store certificate chains, multiple large keys, or the runtime state required by standard TLS/DTLS sessions. As a result, practitioners resort to weaker security parameters, static key provisioning, or very compact cryptographic schemes [23]. These trade-offs raise the risk of key extraction and key reuse attacks and make secure credential lifecycle management more difficult [24].

The cumulative effect of these constraints creates systemic security weaknesses. Forced software implementations and simplified protocols introduce new attack surfaces, and even more capable edge devices require continued optimization. These hardware and computational constraints establish the main challenge that subsequent sections address through specialized privacy-enhancing technologies and optimized anomaly detection approaches.

3.1.2. Trust and Security Management Challenges

The resource-constrained nature of IoT devices makes it hard to build and maintain trust at the device, data, and system levels. Trustworthiness in IoT environments goes beyond conventional security [25] and must account for multiple interdependent properties (see Section 1). In practice, constrained memory, compute, and connectivity force designers to rethink what “trustworthy” means for each layer of the stack.

Implementing trust evaluation models on constrained hardware is challenging. Frameworks such as T-safe [26] illustrate how complex it is to assess trust across different device roles, such as source nodes (sensing data) and relay nodes (forwarding data). However, these models are validated only in MATLAB R2018a or rely on cloud-centric assumptions that do not translate well to distributed edge deployments. This gap between proof-of-concept and field-ready validation limits the models’ practical usefulness [26].

Putting trust mechanisms alongside security protocols exposes further weaknesses. Many current approaches are reactive and fragmented, and suggestions to combine edge computing with AI for trust management frequently lack real-world deployment tests, which hides important scalability and sustainability problems [7]. Without deployment evidence, it is difficult to know whether these integrations will hold up under realistic constraints.

Protocol fragmentation and interoperability issues make trust even harder to achieve. The absence of unified security standards across IoT ecosystems creates trust boundaries that are difficult to bridge, particularly in cross-vendor and cross-domain scenarios [27,28]. This fragmentation is exacerbated by legacy device integration challenges and the proliferation of proprietary protocols that resist standardized trust evaluation.

Data ownership and sharing models add another layer of complexity. Proposed shared-ownership frameworks try to capture dynamic trust relationships [29] but face scalability challenges and inherent trust assumptions that may not hold in practical deployments. The systematic failure to ensure clear data ownership fuels uncontrolled data sharing with third parties, creating cascading trust violations across the IoT ecosystem.

Regulatory fragmentation complicates these technical issues by adding legal and compliance burdens. Conflicting cross-border data flow rules create divergent trust requirements, and many compliance frameworks do not prevent privacy erosion in centralized systems [30]. Effective trust models therefore need to be adaptable to different legal regimes without compromising security or usability.

Taken together, these problems produce a trust management landscape dominated by reactive solutions, unvalidated theoretical frameworks, and scalability paradoxes. Current work too often addresses single trust properties in isolation instead of the holistic, interdependent trustworthiness that constrained IoT ecosystems require. Moving forward will require deployment-validated approaches that balance technical, organizational, and legal realities.

3.1.3. Architectural and Protocol Vulnerabilities

The distributed, heterogeneous structure of IoT ecosystems creates architectural weak points that go beyond any single device’s limitations. Protocol fragmentation and gaps in interoperability become especially harmful when devices are resource-constrained, amplifying systemic security risks.

Protocol security is a major attack surface in many deployments. Wireless Personal Area Network (WPAN) protocols, while tuned for low power, frequently omit full-featured security controls and therefore expose exploitable attack vectors [31]. Inadequate encryption increases the risk of Man-in-the-Middle (MITM) attacks, and simplified authentication mechanisms in constrained protocols facilitate unauthorized access [32,33].

Architectural fragmentation prevents the adoption of unified security standards across IoT. A growing set of proprietary protocols and vendor-specific implementations creates interoperability barriers that compromise standardized security frameworks [27,28]. This fragmentation is particularly problematic in cross-domain scenarios where devices from different manufacturers must exchange trust without a common baseline.

Data-sharing architectures add another layer of risk. When ownership and control are unclear, data routinely flows to vendors and third parties without adequate oversight, producing cascading privacy violations [29,34]. Proposed shared-ownership models try to formalize dynamic trust relationships but still struggle with scalability and fragile trust assumptions that may not hold in practical deployments [29].

Vulnerabilities in communication protocols open many different attack paths. Insecure implementations allow injection attacks that can disable or corrupt core functionality, and ubiquitous connectivity creates endpoints that can be extorted or taken offline [35,36]. Protocol-specific weaknesses in constrained networking standards also enable traffic analysis, replay attacks, and denial of service.

Regulatory and compliance fragmentation amplifies these technical problems. Cross-border data flow regulations create conflicting security requirements, while jurisdictional loopholes are exploited to normalize data exploitation practices [30,37]. Many compliance frameworks focus on enterprise settings and fail to address the special needs of constrained IoT deployments.

Industrial IoT introduces sector-specific architectural challenges. Merging operational technology with information technology surfaces new vulnerabilities, and industry protocols—often legacy or proprietary—frequently lack modern security controls [38]. Compatibility issues between legacy industrial systems and new IoT components further complicate secure integration.

Many proposed multi-layer security frameworks for smart environments remain largely theoretical and untested in constrained, real-world deployments [39,40]. Conceptual, holistic approaches often hit practical limits, computational overhead, interoperability gaps, and scalability problems, when applied across heterogeneous device networks.

These architectural and protocol issues create a security landscape with systemic weaknesses that device-level fixes alone cannot resolve. Addressing this requires integrated solutions that cover protocol design, architecture, and cross-layer defenses, all tailored for resource-limited IoT contexts.

A comprehensive analysis of the key studies examining these hardware, trust management, and architectural challenges is provided in

Table 2. Comprehensive analysis of IoT security constraint studies.

Category	Study	Key Contribution	Identified Limitations
Hardware constraints	[7]	SLR of IoT threats, novel solutions, empirical studies	No real-world case studies
	[41]	ECDH optimization for energy-efficient ECC	Limited to specific elliptic curves
	[20]	Lightweight cryptography (LWC) benchmarking	Superficial analysis, no real-world studies
	[18]	Comprehensive review of 50+ LWC algorithms	No optimal solution identified, limited scope
	[42]	Adaptive data anonymization for power savings and scalable masking	Limited validation and lacks comparison
	[36]	Low-cost voltage fault injection method	Limited device scope and applicability
	[43]	IoT vulnerability taxonomy and practical solutions	No implementation guidelines
Trust management	[25]	Multi-perspective trust mechanism analysis	Lack of critical evaluation framework
	[26]	T-safe trust framework with improved detection	MATLAB-only validation, cloud-centric approach
	[29]	Shared IoT ownership model with dynamic groups	Trust assumptions and scalability challenges
Architectural vulnerabilities	[31]	WPAN security attack/defense taxonomy	Limited critical analysis of proposed defenses
	[33]	Comprehensive IoT vulnerability classification	No practical implementation insights
	[28]	Smart city interoperability survey, broad taxonomy	Theoretical framework
	[27]	Protocol fragmentation analysis	Superficial analysis with feasibility gaps
	[37]	Cross-domain privacy risk analysis, case studies	Technical depth deficiency
	[38]	Integrative review of IoT automation risks	Sector-specific focus limits generalizability
	[32]	3-layer IoT threat model with case studies	Mitigation strategy gaps and CVSS suitability issues
	[30]	Cross-border data flow legal analysis	No technical mitigation strategies provided
	[35]	IoT ransomware case analysis	Surface-level technical analysis
	[39]	Multi-layered smart home security framework	Conceptual framework lacking validation
	[44]	IoT security mechanisms and attack taxonomy	Lacks systematic validation of defense methods
	[40]	Multilayered IoT cybersecurity strategies	Theoretical focus with limited validation
	[34]	Security and privacy concern analysis	Generic solutions without specific implementations

, which summarizes their contributions and the limitations identified in our review. An extended quantitative analysis of these studies, including performance metrics, energy consumption, and device class specifics, is provided in Supplementary Table S1.

3.2. Lightweight Cryptography and Authentication

Lightweight cryptographic solutions are essential for securing resource-constrained IoT devices while maintaining acceptable performance levels. This section analyzes the trade-offs between leading encryption algorithms and authentication protocols optimized for constrained environments.

3.2.1. Lightweight Encryption Algorithms

The choice of encryption for IoT is a trade-off: stronger cryptography provides security but incurs computational overhead, memory usage, and energy consumption. NIST-standardized ASCON [45] has emerged as a practical favorite for constrained devices because it delivers authenticated encryption with low overhead. ASCON’s Authenticated Encryption with Associated Data (AEAD) capability gives both confidentiality and integrity in one step [46], and benchmark studies report efficient software and hardware performance [47,48]—for example, mean processing times of about 80 ms in CupCarbon-simulated IoT networks while keeping strong security guarantees [48].

Traditional AES remains a robust choice for long-term protection, but it depends on hardware acceleration to be practical on ultra-constrained nodes. Comparative analysis reveals that ASCON often outperforms AES when running purely in software on class 0/1 devices, whereas AES keeps the edge on platforms with dedicated crypto hardware [49]. When AES acceleration is not available, ChaCha20-Poly1305 is an efficient alternative: it offers AEAD functionality with good software performance and moderate-term security properties [50], and some resource-constrained implementations report faster software execution for ChaCha20-Poly1305 than for AES-based modes [51].

Specialized, ultra-lightweight ciphers and hybrid schemes solve specific problems but bring additional trade-offs. Algorithms like SPECK are designed for speed and tiny footprints, yet they may raise concerns about long-term cryptanalytic strength [49]. Hybrid compression-plus-encryption schemes reduce transmission volume but overload the endpoints, which can create system-level bottlenecks [52,53]. For multimedia IoT use-cases, crypto-compression approaches have shown roughly 30% faster processing, but they usually require server-side reconstruction, limiting suitability for fully distributed deployments [52].

For images, researchers have explored specialized ciphers that aim for greater diffusion and confusion than general-purpose algorithms can deliver. Notably, Liao et al.’s 3DSFF [54] combines a 3D hyperchaotic generator, a dynamic S-box, and a Fibonacci Q-matrix and reports near-ideal Shannon entropy and strong resistance to differential attacks. However, this security comes at a cost: encrypting a 512 × 512 frame requires roughly 0.55 s on a modern CPU, making real-time video or very large images impractical; even on a Raspberry Pi 5 (class 2 device [12]) the scheme is still well outside the resource envelope of class 0/1 microcontrollers. In short, high-strength, image-specific encryption occupies a different design space from the lightweight primitives intended for ultra-constrained sensing nodes.

In practice, encryption selection must also align with data sensitivity and protection lifespan. Long-term sensitive data (health records and credentials) justifies the use of ASCON or AES despite higher resource costs. For moderate-term protection, ChaCha20-Poly1305 achieves a good balance. For short-lived, low-sensitivity data, performance-optimized options such as SPECK may be acceptable despite potential security trade-offs.

3.2.2. Resource-Efficient Authentication Protocols

Authentication on resource-constrained IoT devices must minimize computational overhead while still verifying identities reliably. Physically Unclonable Functions (PUFs) are attractive here because they provide hardware-rooted trust without storing long-term keys and they resist some forms of physical tampering [55,56].

PUF-based schemes show clear benefits in low-resource settings. For example, PLAKE [55] uses device-specific PUF responses to authenticate devices without key storage, but it can struggle to scale and often depends on backend servers for large deployments. SRAM-PUFs [56] are lightweight and produce high entropy, yet aging and reliability issues mean they need careful provisioning and error correction. Dual-PUF mutual authentication [57] can increase robustness by combining physical traits, but it may create server bottlenecks and stability problems if devices reset frequently.

Cryptographic authentication protocols offer alternative approaches with different trade-offs. ECC paired with HMAC keeps computation low but still lacks broad real-world testing [58]. Identity-Based Cryptography using ECC removes certificates but reintroduces a centralized Private Key Generator as a single point of failure [59]. More experimental ideas—for example, key-exchange schemes inspired by nature and neural techniques—can be energy-efficient but often suffer from synchronization and heterogeneity issues across diverse devices [60].

Choosing an authentication approach means balancing efficiency, storage, and decentralization. PUFs minimize runtime computation overhead and avoid stored keys, but they tie security to hardware quality and lifecycle reliability. Purely cryptographic methods run in software and are more flexible, yet they usually require more processing and can reintroduce centralized trust or coordination points. Practical deployments often use hybrids or add corrective mechanisms (e.g., error correction for PUFs and lightweight key management) to manage these trade-offs.

A compact comparison of security strength, resource cost, and decentralization for the lightweight encryption and authentication options discussed here is presented in

Table 3. Comparison of lightweight cryptographic approaches for constrained IoT.

Category	Approach	Resource Efficiency	Security Strength	Limitations
Encryption Algorithms	ASCON (NIST) [47,48]	High (SW/HW)	Strong (AEAD)	Emerging standard, less field testing
	AES-128 [61]	Medium (HW) Low (SW)	Very Strong	Resource-intensive without acceleration
	ChaCha20-Poly1305 [50]	High (SW)	Strong (AEAD)	Moderate-term security focus
	SPECK [49]	Very High	Moderate	Potential long-term security concerns
PUF Authentication	PLAKE [55]	Very High	Hardware-based	Scalability issues, server dependency
	SRAM-PUF [56]	Very High	Physical security	Aging reliability concerns
	Dual-PUF [57]	High	Enhanced physical security	Server bottleneck, stability issues
Crypto Authentication	ECC-HMAC [58]	High	Cryptographic	Limited real-world validation
	IBC-ECC [59]	Medium	Certificate-free	Centralized PKG vulnerability
	Neural-GSA [60]	Medium–High	Adaptive security	Synchronization challenges

. A more detailed breakdown of the individual studies and their limitations is provided in

Table 4. Comprehensive analysis of lightweight cryptography and authentication studies.

Category	Study	Key Contribution	Identified Limitations
Encryption techniques	[54]	3D-LMM hyperchaotic encryption for images	High computational overhead, incomplete practical IoT fit
	[48]	ASCON in CupCarbon simulator networks	Limited AEAD functionality analysis
	[49]	SPECK vs. ASCON performance comparison	Ignores energy consumption analysis
	[62]	Wearable IoT encryption selection guide	Lacks technical depth and validation
	[52]	Image crypto-compression for MIoT	Requires SRGAN server reconstruction
	[63]	Comprehensive 24+ LWC algorithm survey	Scope limitations and data heterogeneity
	[64]	LWC process with deterministic keys	Tested only on image data
	[65]	Ultra-LWC algorithm with high throughput	Non-IoT hardware testing
	[66]	Twofish cloud integration	Hardware dependency, short-term data focus
	[47]	ASCON hardware implementation	No AEAD comparison with alternatives
	[53]	Hybrid compression–encryption framework	Ignores energy, limited scalability
	[21]	Crypto-algorithm benchmarking	No energy evaluation, limited testbed
	[67]	ECDH-based onion routing	High energy use, narrow testing scope
	[61]	Layered AES+TLS security	Single gateway failure risk
Authentication protocols	[57]	Dual-PUF mutual authentication	Server bottleneck, PUF degradation
	[55]	PUF-based PLAKE protocol	Scalability issues, server dependency
	[59]	IBC+ECC mutual authentication	PKG dependency, lacks validation
	[58]	ECC+HMAC lightweight authentication	No real-world validation
	[60]	Neural key exchange with GSA	Synchronization challenges
	[56]	SRAM-PUF authentication	Aging sensitivity, lacks comparison

. Supplementary Table S2 offers an extended comparative analysis of these schemes, detailing testbed environments, performance benchmarks, and resource costs for constrained hardware.

The cryptographic landscape for constrained IoT is fundamentally a set of trade-offs: stronger guarantees usually cost CPU cycles, memory usage, and battery life. Lightweight AEAD schemes such as ASCON [45] are a good starting point, and PUF-based authentication [55] can provide hardware-rooted identity verification. That said, a secure, practical deployment depends on matching choices to device class, realistic threat models, and how devices operate in the field (e.g., connectivity patterns, update cadence, and expected lifetime).

Key implementation considerations are as follows:

• Hardware dependencies significantly affect algorithm throughput and energy use (e.g., AES with hardware accel vs. pure-software ASCON);
• Distributed key management remains challenging—provisioning, rotation, and revocation must fit constrained lifecycles;
• Protocol interoperability determines how well a solution scales across vendors and domains;
• Long-term security requirements (e.g., how long data must remain confidential) should be weighed against immediate resource limits.

Therefore, effective IoT cryptography needs tailored approaches. It requires encryption algorithms and authentication mechanisms chosen for the target hardware, validated on representative devices, and supported by realistic operational practices, like threat modeling, lifecycle plans, and interoperable protocols, so security gains do not collapse under real-world constraints.

3.3. Privacy-Enhancing Technologies for Constrained Environments

Privacy-enhancing technologies (PETs) provide critical protection for sensitive IoT data while addressing the fundamental constraints of resource-constrained devices. These techniques balance privacy preservation with the computational, memory, and energy limitations of class 0/1 IoT devices, enabling secure data processing without compromising device viability.

3.3.1. Federated Learning for Distributed Privacy

Federated learning (FL) lets many IoT devices train a shared model without sending raw data to a central server. Devices keep sensitive records locally and only share model updates, which helps with privacy and reduces bandwidth needs in constrained deployments [9].

Edge-focused implementations show that FL can work even on class 0/1 devices. For instance, PrivStream [68] executes lightweight MLP/RNN models locally and applies differential privacy noise to the model updates, thereby minimizing the attack surface for applications such as healthcare monitoring, albeit with some loss of generality. Likewise, Astillo et al. [69] demonstrate that compressed and quantized CNN/MLP models running on Raspberry Pi nodes can support diabetes management tasks, preserving accuracy while avoiding centralized data aggregation.

At the same time, FL brings practical and security headaches in constrained settings. Frequent model update exchanges can overwhelm low-bandwidth links and drain batteries, so efficient communication protocols, compression, and sparsification are essential. In this context, feature selection can dramatically reduce FL communication overhead. Wang et al. [70] used mutual information to reduce features from 85 to 16, enabling federated DNN training with only a 4.32 MB communication cost versus 3.54 GB for centralized approaches while achieving 99.4% accuracy in simulations—showing how preprocessing optimizations make deep learning feasible in federated IoT settings.

Statistical heterogeneity—clients holding non-independent and identically distributed data—slows convergence and can bias global models, which is why recent work favors personalization layers, meta-learning, and client-aware aggregation strategies to make FL robust in real-world IoT networks [71].

Cross-layer optimization offers one route to lowering the resource burden associated with FL on constrained devices. Hajj et al. [72] combine cluster-based sampling with a federated baseline K-means model, reducing inference latency on an Arduino Nano 33 from 32 ms to 9 ms while retaining a recall of 0.97 for intrusion detection. This result further demonstrates that thoughtful preprocessing can make FL feasible even for class 0 hardware.

In real-world deployments, slow devices, intermittent connectivity, and devices frequently joining or leaving make synchronized model updates difficult. To handle this, FL systems require robust scheduling or must adopt asynchronous or hierarchical designs. Lastly, model update privacy and integrity are open concerns: naive update aggregation can leak private information and is vulnerable to corruption or backdoor attacks, requiring secure aggregation, differential privacy mechanisms, and Byzantine-resilient aggregation to defend against malicious clients [73]. Note that many of these protections increase computation and communication overhead, so their deployment must be budgeted against device constraints [74].

To make FL practical and privacy-preserving for IoT, a co-design approach is essential. This involves tailoring model architectures, compression (e.g., quantization), secure aggregation, and scheduling policies to real-world device profiles. Such integration is the key to managing the inherent computational overhead and overcoming deployment hurdles like synchronization challenges and heterogeneous device capabilities in practical IoT scenarios.

3.3.2. Differential Privacy for Data Protection

Differential privacy (DP) protects individuals by adding carefully calibrated noise to data or computations, making re-identification much harder while still allowing useful analysis [75]. The mathematical guarantee—applied locally on the device or to model updates—fits well with constrained IoT because it can be implemented with modest overhead in some constrained setups when carefully tuned, but overhead depends on privacy parameters, aggregation scheme, and implementation. In short, DP lets devices keep raw data on-device and share only noisy summaries, which preserves aggregate utility while reducing privacy risk [68].

On-device DP work shows that this approach can be both practical and fast. For example, an OCSVM-based method with DP guarantees [76] reported 99.18% detection accuracy while running locally on constrained hardware, and it processed flows about 40× faster than deep learning alternatives in the authors’ tests. These kinds of results make DP attractive for latency-sensitive, privacy-critical use cases (e.g., health monitoring or local anomaly detection), where sending raw data off-device is unacceptable.

That said, DP requires careful tuning to be useful. The noise level—commonly controlled by the epsilon parameter—directly trades privacy for utility. This parameter should be chosen with the application’s sensitivity and the device’s capabilities in mind. In ultra-constrained devices, simplified or hybrid DP variants (e.g., reduced computation, coarser noise injection mechanisms, or occasional offload to gateway nodes) can offer practical protection without the full cost of a complete DP stack.

3.3.3. Edge–Cloud Privacy Frameworks

Hybrid edge–cloud architectures split work between local devices and remote servers: sensitive data stays on the edge while computationally heavy tasks such as model training, complex analytics, or large-scale encryption run in the cloud. This trade-off makes privacy-preserving workflows feasible even for class 0/1 devices by offloading expensive operations while keeping raw data local, which also helps with bandwidth and latency constraints.

Cloud-assisted frameworks show how this can scale in practice. For example, RT-PPS [77] uses multi-authority encryption and separated trust domains to enable secure cross-organizational sharing with low latency. Likewise, MPC-based solutions process encrypted data shares across multiple clouds for tasks such as real-time fall detection [78]; however, their reliance on cloud infrastructure can limit applicability in truly decentralized or intermittently connected deployments.

Beyond cloud-assisted frameworks, lightweight tokenization schemes [79] offer practical on-device privacy for traffic inspection, helping block MITM threats with minimal processing overhead. Similarly, adaptive privacy mechanisms [80] allow devices to dynamically adjust protection levels—such as using stronger encryption for sensitive health data while relaxing it for routine telemetry—based on context and available resources.

Techniques for encrypted processing extend protection to data in use. Encrypted image retrieval systems [81,82] let IoT data from cameras and sensors be analyzed without exposing raw imagery, using methods like locality-sensitive hashing and CNNs on encrypted representations. These approaches reduce surveillance risk and keep computation tractable through careful algorithmic optimization, though they do add complexity and sometimes extra latency that must be accounted for in system design.

In summary, selecting PETs for constrained IoT involves choosing the minimal set of protections that match the operational context. Federated learning preserves raw data on-device but requires communication optimization. Differential privacy provides mathematical guarantees with tunable noise. Edge–cloud hybrids offload intensive tasks while keeping sensitive data local. Complementary lightweight privacy primitives—including tokenization, adaptive mechanisms, and efficient encryption schemes—offer additional, context-aware layers of protection. The viability of these techniques for class 0/1 devices is summarized in

Table 5. Privacy-enhancing technologies for resource-constrained IoT.

Technique	Class 0/1 Viability	Privacy Benefits	Resource Considerations
Federated learning	Medium (with optimization)	Raw data remains on-device, only model updates shared	Requires careful model sizing, gradient compression, participant scheduling
Differential privacy	High	Mathematical privacy guarantees, calibrated noise injection	Low computational overhead, epsilon parameter tuning critical
Edge–cloud frameworks	High (edge component)	Distributed trust, encrypted processing capabilities	Cloud dependency for complex operations, bandwidth usage
Lightweight encryption	High	Data confidentiality with minimal overhead	Balanced security–performance trade-offs required

.

PETs for constrained IoT force a simple trade-off: better privacy usually costs CPU, memory, or battery. Federated learning and differential privacy are good fits for many class 0/1 scenarios—FL when you can tolerate periodic model exchanges and DP when noisy summaries are sufficient—while edge–cloud hybrids let tiny devices participate in stronger workflows by offloading the heavy work. Choosing the right mix depends on the device class, how sensitive the data are, and what the application can tolerate in latency and energy use.

Implementation guidelines for constrained environments are as follows:

• Match model complexity to the device’s capabilities;
• Set privacy budgets that reflect data sensitivity and real-world risk, not arbitrary defaults;
• Use hybrid architectures to push intensive tasks to the cloud while keeping raw data and short-lived processing at the edge;
• Prefer adaptive schemes that raise protection for critical data and relax it for low-value telemetry when resources are tight.

PET research continues to narrow the gap between strong privacy guarantees and tight resource budgets. Current work focuses on communication-efficient FL, lightweight DP variants, and edge-aware encrypted processing so that deployed systems can offer robust privacy without overwhelming constrained hardware.

Table 6. Comprehensive analysis of privacy-enhancing technology studies.

Category	Study	Key Contribution	Constraints for Class 0/1 Devices
Edge computing	[76]	OCSVM with local processing and low-latency detection	No encryption, TCP-only focus, Python overhead
	[83]	TinyML + blockchain for industrial IoT	High blockchain overhead, PLC-only communication
	[72]	Cross-layer FL with cluster-based sampling for lightweight IDS	Sampling degrades detection over time, requires periodic FL merging
	[70]	Feature selection enables federated DNN	Simulation-based, no embedded validation
	[68]	DL + DP for real-time adaptive privacy	Limited dataset testing, model-dependent adaptability
Cloud-assisted	[82]	CNN-LWE hybrid for fast feature extraction	Edge server dependency, scalability challenges
	[77]	Multi-authority ABE with low latency	No overhead analysis, VM testing limitations
	[78]	MPC-based real-time fall detection	Cloud dependency limits standalone operation
	[81]	Encrypted image retrieval with SURF/LSH	Scalability issues, parameter sensitivity
Hybrid approaches	[80]	Multi-technique utility–privacy balance	Scalability issues in real-world deployment
	[79]	Encrypted traffic inspection with low overhead	No IoT hardware validation, accuracy metrics unclear
Survey	[84]	Comprehensive ML/DL anomaly detection review	Lacks critical analysis of constrained deployments

summarizes the studies discussed in this section and the specific constraints they identify for class 0/1 devices. For a detailed breakdown of implementation performance, privacy guarantees, and resource metrics across these PET studies, see Supplementary Table S3.

3.4. Real-World Breach Analysis and Mitigations

Real-world IoT security breaches provide critical insights into systemic vulnerabilities and the practical consequences of security failures in constrained environments. Analysis of high-impact cases reveals recurring patterns that highlight the necessity of integrated privacy-enhancing technologies and anomaly detection strategies.

3.4.1. High-Impact Breach Case Studies

Mirai shows how a small flaw becomes a huge problem. By probing devices that still used factory-default credentials, the malware quickly turned large numbers of IP cameras and routers into a botnet used for massive DDoS attacks [85,86]. That the same basic technique keeps resurfacing in later variants underlines how often fundamental authentication gaps go unaddressed [87,88].

The Jeep Cherokee case highlighted risks in connected vehicles. Security researchers were able to reach the infotainment system remotely and from there interfere with steering, braking, and acceleration—a clear demonstration that entertainment and safety functions must be separated and strongly controlled [89]. Later incidents such as the reported Kia web portal vulnerabilities [90] show that these interface problems are still a real threat.

Consumer IoT failures tell a similar story. In the Ring doorbell incident, attackers captured Wi-Fi credentials during a reconfiguration flow that exposed them in plaintext over HTTP, allowing unauthorized access to users’ networks and devices [91]. This failure in basic data protection highlights the consequence of inadequate encryption.

Complex devices multiply the danger. The Akuvox intercom compromise combined multiple flaws that allowed unauthorized entry, remote code execution, and covert use of cameras and microphones [92]. This case illustrates how complex IoT devices can introduce multiple attack vectors when security is not integrated throughout the design lifecycle.

Trend Micro’s work found internet-connected speakers exposing data and network details through unauthenticated web interfaces—items that are trivial to find with tools like Nmap and Shodan [93]. The same pattern appears in odd places too: researchers even demonstrated how insecure Bluetooth-enabled toys can leak audio and personal information [94].

Recent large-scale incidents underline the stakes. A 2025 leak exposed billions of Wi-Fi credentials and device records from a poorly protected database, showing how misconfigured data stores become high-value targets [95]. Long-term monitoring studies also reveal accelerating attack cycles and a bias toward ARM-targeting malware, stressing that default settings, weak segmentation, and exposed data remain systemic problems [96].

3.4.2. Systemic Vulnerability Patterns

Analysis of these breaches shows a handful of recurring failures. The easiest entry point remains default credentials: attackers exploited unchanged factory logins to build the Mirai botnet at scale [85]. Poor patch management compounds the problem—unpatched firmware gives malware a steady target and shortens attackers’ time to exploit, as long-term monitoring studies demonstrate [96]. Insecure APIs and web interfaces expose critical functions that accept remote commands without strong authentication. These software gaps are worsened when data in transit is left unencrypted, making secrets like Wi-Fi passwords easy to intercept, and when networks lack segmentation, allowing attackers to move from compromised consumer-facing systems into safety-critical zones.

3.4.3. Derived Mitigation Strategies

The incidents point to a compact set of practical defenses that work together. First, eliminate default credentials and enforce device-unique identities—preferably anchored in hardware roots of trust (e.g., PUFs or secure elements) so credentials cannot be trivially cloned. Second, put robust firmware lifecycle controls in place: signed, integrity-checked over-the-air updates with mandatory verification before installation. Third, harden all exposed interfaces by applying strict API security practices (e.g., input validation, authentication, authorization, and rate limiting) and by minimizing administrative surfaces. Fourth, require end-to-end encryption for all sensitive channels so credentials and telemetry are never sent in plaintext. Finally, adopt fine-grained network micro-segmentation to isolate non-critical services from safety-critical functions, limiting lateral movement after a compromise. Combined, these measures address the common failure modes observed across the case studies.

Underpinning all these technical controls is the demonstrated need for an integrated privacy-enhancing technology and anomaly detection (PET-AD) approach; for instance, while Mirai exploited an authentication failure, anomaly detection could have flagged its unusual network behavior, just as behavioral monitoring could have detected the interface bypassing in the Jeep Cherokee and Kia hacks.

These breach cases, their corresponding technical mitigations, and the essential role of an integrated PET-AD approach are systematically mapped in

Table 7. Breach analysis and corresponding mitigation strategies.

Breach Case	Primary Vulnerability	Technical Mitigation	PET-AD Integration
Mirai botnet	Default credentials, unpatched firmware	PUF-based authentication, secure OTA updates	AD: Network behavior analysis for botnet detection PET: Encrypted device authentication
Jeep Cherokee	Insecure APIs, insufficient segmentation	API hardening, network micro-segmentation	AD: Anomalous control command detection PET: Secure communication channels
Ring doorbell	Unencrypted data transmission	Lightweight end-to-end encryption	AD: Unusual reconfiguration pattern detection PET: Encrypted WiFi credential exchange
Akuvox intercom	Multiple vulnerabilities, weak access controls	Comprehensive security testing, hardware security	AD: Unauthorized access pattern recognition PET: Encrypted media streams

.

These vulnerabilities keep reappearing long after they were first exposed, which makes one thing clear: small fixes are not enough. The pattern of repeat incidents shows that we need deeper changes to how IoT systems are designed and protected. Combining privacy-enhancing technologies (PETs) with anomaly detection (AD) gives a layered defense that tackles both prevention failures and the detection gaps exposed by real-world breaches.

Practically, that means shifting from retrofitting security to a “security by design” mindset. Start with hardware-rooted trust (secure elements or PUFs) and automated integrity-checked update mechanisms that work on constrained devices and pair them with continuous monitoring and preventive controls at the edge and in the network. When these elements are integrated—cryptographic protections, access controls, and behavior-based detection—they form a resilient defense-in-depth approach.

The case-study evidence in this review shows that the PET–AD integration is not just theoretical: it is a necessary, practical strategy for addressing the kinds of compromises we keep seeing in the wild. Real gains will come from implementing, testing, and iterating these integrated solutions on representative devices and deployments.

3.5. Advanced Security Enablers: AI/ML and Blockchain

In the context of constrained IoT, the integrated PET–AD paradigm is supported by two technological domains: artificial intelligence and machine learning (AI/ML) and blockchain. AI/ML supplies the adaptive capability required for efficient, on-device anomaly detection and forms the methodological foundation for privacy-preserving approaches such as federated learning. Blockchain, by contrast, provides an architectural means to distribute trust and produce verifiable audit trails, thereby addressing vulnerabilities in distributed PET–AD workflows—most notably secure model aggregation and tamper-evident logging. Rather than regarding these technologies as adjacent, this section examines AI/ML and blockchain as enablers of the PET–AD framework and evaluates their practical viability in light of the severe computational, memory, and energy constraints characteristic of class 0/1 devices and the systemic gaps identified in our breach analysis (Section 3.4).

3.5.1. Artificial Intelligence and Machine Learning for IoT Security

Within the PET-AD framework, AI/ML’s primary value lies in implementing resource-aware anomaly detection and enabling scalable privacy-preserving computation. For instance, ML models form the core of detection agents in systems like R-IDPS [97] in Software-Defined Networking and reports 97–99% accuracy against certain attacks, though its coverage is limited and it has mainly been tested in simulated settings. Work by Illy et al. [98] shows modest accuracy gains (around 5–10%) when multiple features are combined in home environments, and hybrid methods such as the Artificial Orca Algorithm with ensemble learning [99] can improve detection further, at the cost of added computational complexity.

Researchers are actively pushing ML toward the edge so that these gains become practical on constrained hardware. Hardware acceleration approaches like Al-rubaye et al. [100] pair Google Coral TPUs with Raspberry Pi 5 and use quantized models that reduce inference latency by more than half. Such hardware-aware optimizations are not just for standalone detection; they are prerequisites for deploying practical federated learning (a key PET) on edge nodes, making local model training and update generation feasible within tight power budgets.

For severely constrained devices, offline SVM training techniques have shown dramatic energy savings (up to 350× lower energy in [101]), although they introduce longer training times and risks like SRAM overflow. Hybrid IoT–cloud setups, such as Shahid et al.’s ensemble framework for water quality prediction [102], can be useful in practice but face challenges with dataset overfitting and unvalidated energy consumption.

Communication-efficient deep learning is important for distributed IoT security. Wang et al. [70] demonstrated that federated DNNs with mutual information feature selection outperform centralized and other FL methods in both accuracy (99.4%) and communication efficiency in simulation environments, providing a template for privacy-preserving deep learning in resource-aware deployments.

Therefore, the evolution of AI/ML for constrained IoT is pivoting from pure accuracy metrics towards co-designing lightweight models and training schemes that align with the taxonomy’s resource dimensions (Section 4). This enables their dual role as both efficient anomaly detectors and as the computational backbone for privacy-preserving techniques like FL and DP.

3.5.2. Blockchain-Enabled Security for IoT

Blockchain technology helps resolve a central tension in distributed PET–AD systems: how to establish verifiable trust and coordination in the absence of a central authority. This capability is important for securing operations such as model aggregation in federated learning and for maintaining immutable logs of detected anomalies. The attributes typically associated with blockchain—decentralized trust, verifiability for audit, and the reduction in single points of failure—can therefore mitigate many of the risks inherent to centralized architectures that have been exploited in past breaches [86,90]. For example, hybrid approaches that combine searchable symmetric encryption with neural network-based analytics offer a promising path for protecting data access while keeping latency within acceptable bounds; nevertheless, challenges remain with legacy system compatibility and additional computational overhead [103].

To make blockchain practical for constrained IoT, researchers propose hybrid architectures that mix lightweight ledgers with off-chain computation. Some implementations demonstrate acceptable latency on devices such as ESP32 and Raspberry Pi, but they still depend on platform-specific features and may expose unquantified risks from external services [104]. Decentralization helps against attacks that exploit centralized update and credential mechanisms (as with Mirai [85]), but it does not remove all operational or integration hurdles. These hybrid models represent a specific trade-off within our taxonomy Section 4, opting for a fog/cloud deployment paradigm to manage the communication and computational constraints of class 0/1 devices, while still providing a decentralized trust layer for PET-AD operations.

In summary, AI/ML and blockchain are not peripheral but pivotal to realizing the integrated PET-AD vision for constrained IoT. AI/ML provides the adaptive intelligence for both efficient anomaly detection and the machinery of privacy-preserving computation. Blockchain offers an architectural paradigm to decentralize trust, critical for secure and verifiable PET-AD operations in distributed networks. The paramount challenge, as with all components in this review, is their co-design into resource-conscious protocols that respect the strict energy, memory, and computational limits of the IoT edge, transforming theoretical robustness into deployable trustworthiness.

4. Anomaly Detection in IoT Data

Anomaly detection in IoT matters for both safety and security. It spots faults that could cause physical harm and flags malicious activity that threatens system integrity. In practice, this means continuously monitoring sensors, logs, and data streams for deviations from expected behavior—for example, an unexpected temperature spike on an industrial sensor or an unusual sequence of control commands. Because it protects multiple trust properties (see Section 1), anomaly detection is a versatile building block for resilient IoT systems.

4.1. Classification of Anomaly Detection Techniques in IoT

Most existing taxonomies classify anomaly detection along a single axis (e.g., by application or algorithm). Even multi-view efforts such as [105]—which consider the nature of the anomaly, analyzed data, detection principles, and application domain—do not fully capture the constraints unique to IoT deployments. To close this gap we propose a five-dimension taxonomy (Figure 1) that explicitly incorporates IoT realities: deployment paradigm (edge/fog/cloud), resource constraints (computation/memory/energy), real-time needs (stream vs. batch processing), protection techniques (privacy/security requirements), and communication constraints (compression/event-driven reporting). This multi-dimensional view makes it easier to pick detection approaches that actually fit the device class and operational context.

The five-dimensional taxonomy emerged through an iterative, grounded examination of the studies collected in our systematic review. We extracted key design attributes—such as hardware platform, energy footprint, and privacy mechanisms—from each work and grouped them into clusters. Through successive refinements, these clusters converged into five dimensions that, taken together, offered a sufficiently concise yet expressive structure for capturing the main design tensions and constraints reported in the literature. In this way, the taxonomy remains closely tied to empirical evidence and reflects the practical challenges faced in constrained IoT settings.

To explore the taxonomy’s usefulness in practice, we applied it to three representative IoT anomaly detection systems: PrivStream [68], TEDA [106], and IoTREPAIR [107]. As shown in

Table 8. Practical application of the taxonomy.

Taxonomy Dimension	PrivStream [68]	TEDA [106]	IoTREPAIR [107]
Deployment paradigm	Edge	Edge (microcontroller)	Fog-layer federation
Resource constraints	Computation: Medium (MLP/RNN models) Memory: Optimized (streaming filters) Energy: Medium (continuous sensing)	Computation: Ultra-Low (TEDA algorithm) Memory: Minimal (no stored data) Energy: Ultra-Low (event-driven)	Computation: High (neural networks) Memory: High (model training) Energy: Offloaded (Fog layer)
Real-time requirements	Stream processing	Stream processing	Batch processing (model updates)
Protection techniques	Privacy preservation: Differential privacy (DP)	Privacy preservation: None	Privacy preservation: Federated learning (FL)
Communication constraints	Event-driven	Event-driven	Gradient compression

, the taxonomy captures the central design trade-offs embodied in each system, supporting comparative analysis and broader design space reasoning. While this internal validation indicates that the taxonomy is consistent and applicable across diverse cases, its value would be strengthened through external expert assessment and use in guiding the development of new system architectures. We therefore present the taxonomy as a conceptual tool intended to support more systematic research and design in resource-constrained IoT environments, rather than isolated solution-specific advances.

Considering the deployment, there are three well-known computing architectures: edge, fog, and cloud computing. The anomaly detection mechanism can be implemented in any of them, but its performance will be affected by the characteristics of the computing paradigm. Powerful computations can be performed in the cloud; thus a more complex algorithm and a larger amount of data can be used for anomaly detection. Performing it in the fog or edge layer leads to reduced latency.

The resource constraints refer to the challenges that often characterize IoT systems: reduced computational power, memory, and energy resources. To overcome them, anomaly detection techniques must be optimized. This category contains the following sub-criteria:

• Computation—lightweight algorithms are designed to overcome the problem of the limitation of computational power. They include simple statistical methods (e.g., min–max thresholds and moving average), dedicated designed algorithms (e.g., TinyML), and lighter machine learning models (e.g., decision trees and kNN). Approximate computing helps to reduce computational load by trading off solution accuracy for significant computational savings (e.g., lower-precision arithmetic for distance calculations in k-NN or approximate nearest neighbor search [108]).
• Memory usage—storing all read sensor data to be used at once by the anomaly detection method cannot always be performed due to the device specifications. In streaming algorithms one record can be examined in only a few passes, typically just one (e.g., streaming K-means [109]). Incremental learning models learn from new data as it arrives. Similarly to humans, they square new information over time. Incremental principal component analysis is a good solution when the dataset to be decomposed is too large to fit in memory.
• Energy consumption—optimizing the data processing pipeline can reduce energy consumption [110]. Data collection can be triggered by specific events or thresholds (e.g., sudden temperature increase). Thus, anomaly detection will be performed less often.

In most IoT applications, real-time or almost-real-time anomaly detection is expected to enable timely responses. Only the results can be stored or transmitted further, so that IoT devices still have resources. Using this criterion, we can identify the following classes:

• Stream processing—data streams are processed in real time, for instance stream clustering or real-time filtering [111].
• Batch processing—a specific quantity of data [112] (e.g., daily electricity consumption [113]) is used to detect anomalies.

Protection techniques are crucial in IoT systems, as most of them operate with sensitive data. In this category, the following sub-criteria can be used:

• Privacy preservation techniques—the identity and sensitive information of individuals or entities can be protected by implementing anomaly detection in an FL environment [114]. Only parameters of the detection models are shared. Another solution is localized anomaly detection. Anomalies are identified locally on the IoT device, and the results are transmitted further, not the raw data.
• Secure data processing—this refers to protecting data during storage, transmission, and computation. Encryption and anonymization techniques ensure secure data processing (e.g., differential privacy [75]). Secure hardware builds trusted execution environments able to perform anomaly detection to identify unauthorized access.

Anomaly detection technique implementation should consider minimizing the amount of data transmitted so that the communication constraints are respected. Considering these, two classes have been identified:

• Data compression—not transmitting all the collected data reduces the communication load. Lossless compression techniques reduce data size but conserve the encapsulated information. These approaches are suitable for applications where data integrity is crucial [115]. Lossy compression reduces data size by losing the less important information [116]. It is suitable for applications where cost reduction is more important than accuracy in anomaly detection.
• Event-driven communication—data transfer is triggered by specific events, resulting in reduced data amounts transmitted over the network [117]. In anomaly-driven reporting, only the anomalous data is transmitted.

Table 8 applies the taxonomy to three real systems to show how different design choices suit different IoT needs. For example, PrivStream [68] is well suited to latency-sensitive elderly-care monitoring because it runs on the edge and uses differential privacy for streaming data. By contrast, TEDA [106] fits ultra-constrained scenarios with low privacy requirements (such as vehicular pavement anomaly detection) since it demands very little computation, even though it lacks privacy safeguards. For large-scale malware hunting across distributed networks, IoTREPAIR [107] is the pragmatic choice because it shifts work to the fog layer and uses federated learning with gradient compression to strike a balance between computational load and privacy.

This classification reveals that no single technique excels in all dimensions; each represents different trade-offs appropriate for specific contexts. The taxonomy makes these trade-offs explicit, moving beyond one-size-fits-all approaches to enable a systematic, context-aware anomaly detection method selection for resource-constrained IoT environments.

4.2. Causes of Anomalies in IoT Systems

Anomaly detection techniques identify abnormal behavior that may indicate various faults or failures within IoT systems. The most common causes are summarized in

Table 9. Causes of anomalies in IoT systems.

Anomaly Cause	Description	Examples
Faulty sensors	Due to extended operation or harsh environments, sensors may report erroneous readings or fail prematurely	Spatial correlation with ML models detects faulty sensors in smart farming [118]
Cybersecurity threats	Malware, DDoS, MITM, and other attacks can compromise device behavior and data integrity	Refs. [107,119,120] use FL-based frameworks, neural networks, and SDN–blockhain hybrids to detect cybersecurity attacks in network traffic data
Data-related issues	Data drift, outliers, duplicates, missing values, and inconsistencies in sensor readings	Refs. [121,122,123] use ML and statistical algorithms to detect anomalies in resources consumption (water and electricity)
Unusual behavior of the system	Legitimate but unexpected system behavior due to environmental or operational changes	Rule-based systems like SecurHome [124] for elderly monitoring
Physical attacks	Sensor tampering, removal, or modification leading to unauthorized access, disruption of IoT services, security breaches, and device malfunctions	Gateway-based detection using supervised and unsupervised learning [125]

, ranging from hardware degradation to complex cyber attacks.

Faulty sensors are a persistent problem in long-term IoT deployments. The method in [118] separates normal, faulty, and compromised sensor behavior by combining spatial correlation theory with machine learning. In a smart-farming testbed, the authors report 98.9% accuracy using CART, Random Forest, and SVM classifiers.

Detecting cybersecurity threats calls for different techniques. IoTREPAIR [107] uses federated learning with MLPs and autoencoders to spot malware, but its validation is simulation-based, which limits confidence in field deployments. DIOT [119] treats network traffic like language and applies Gated Recurrent Unit (GRU) neural networks, reporting 95.6% detection with a 257 ms response time.

Anomalies in data quality crop up across many domains. Studies on water systems [121] and electricity consumption [122,123] typically blend statistical checks with machine learning models. These hybrid approaches perform well, but their need for centralized data often clashes with privacy constraints in real deployments.

The causes and corresponding detection techniques demonstrate that anomaly detection spans both safety and security domains. In IoT environments, these domains frequently intersect—security breaches can directly cause safety hazards, necessitating comprehensive monitoring approaches.

4.3. Anomaly Detection on Embedded Devices

Edge-based anomaly detection on embedded devices requires specialized approaches to balance detection accuracy with resource constraints. Hardware platforms like Arduino, ESP, and Raspberry Pi enable real-time processing while minimizing latency and bandwidth usage.

Mechanical anomaly detection demonstrates the feasibility of embedded ML implementations. Lord & Kaplan [126] deploy autoencoder and variational autoencoder networks on Arduino Nano 33 BLE Sense for washing machine monitoring, achieving 92% accuracy with 5-s inference intervals. The significant performance difference between autoencoder (92%) and VAE (66%) models highlights the importance of model selection for constrained devices.

TinyML solutions optimize for ultra-low-resource environments. Andrade et al. [106] implement the TEDA algorithm on Arduino Nano 33 IoT for pavement anomaly detection, achieving 99% accuracy with minimal computational and memory overhead. However, TEDA’s sensitivity to feature representation and threshold selection requires careful context-specific tuning.

In an industrial IoT context with extreme environmental constraints, Antonini et al. [83] report a fully autonomous TinyML-based anomaly detection system built around an ESP32 microcontroller. The prototype executes an Isolation Forest model locally, with inference latencies below 16 ms and a memory footprint of roughly 84 KB RAM. A notable aspect of their design is the use of blockchain to provide auditability: anomaly events are signed and recorded on the Ethereum network, yet raw sensor readings remain on the device. This work illustrates how coordinated design across edge computing, TinyML inference, and blockchain-backed logging can support trustworthy monitoring in demanding industrial settings, although the blockchain layer introduces non-trivial overhead (560 bytes per transaction).

In the network security domain, Hajj et al. [72] present an intrusion detection system based on federated k-means running on the Arduino Nano 33 platform. Rather than transmitting raw records, the nodes share only cluster statistics during the learning process. Their cross-layer design illustrates how lightweight unsupervised models paired with selective communication can support collaborative defense while remaining within the device’s strict memory limit of 256 KB RAM.

Medical IoT applications demonstrate privacy-preserving edge detection. Astillo et al. [69] combine federated learning with CNN/MLP models on Raspberry Pi devices for diabetes management, achieving 99.17% accuracy while maintaining data confidentiality through model compression and quantization.

These embedded implementations demonstrate practical applications of the taxonomy’s resource constraints dimension, showing how detection algorithms must be optimized for specific hardware capabilities. This is further evidenced by frameworks that combine lightweight statistical anomaly detection with efficient encryption on Raspberry Pi and ESP8266 nodes, achieving real-time analysis without cloud dependency [51].

A detailed comparative analysis of the key anomaly detection methods discussed, including their performance on specific hardware classes, accuracy, and resource usage, is consolidated in Supplementary Table S4.

4.4. Adversarial Attacks on IoT Anomaly Detection Models

The integration of AI/ML models introduces vulnerabilities to adversarial attacks, where carefully crafted perturbations cause misclassifications while appearing normal to human observers. In IoT, attackers can exploit this by tweaking sensor readings or shaping network traffic so detectors miss intrusions or raise false alarms [127].

The consequences are most severe in safety-critical settings such as health monitoring [128], where a manipulated signal could hide a real emergency or trigger unnecessary emergency responses. Because many IoT nodes are resource-constrained to run heavy defenses or stream everything to the cloud, we need lightweight, practical countermeasures that work on-device or at nearby edge nodes.

Useful directions include simple input-cleaning filters like feature smoothing that strip out adversarial noise [129] and training strategies that account for low-precision deployment, such as quantization-aware adversarial training [130]. Field studies like IoTREPAIR [107] also show that adversarial attacks can sharply reduce federated learning accuracy, which means that aggregation rules and validation checks must be hardened as well.

However, applying such defenses to severely resource-constrained nodes presents significant challenges. The practical deployment of defenses such as quantization-aware adversarial training on class 0/1 devices remains severely constrained. Generating adversarial examples and performing robust training introduces memory and computational demands that typically exceed the resources of microcontrollers equipped with less than 50 KB of RAM and sub-100 MHz CPUs (Section 3.1.1). For these ultra-constrained nodes, defensive measures must therefore rely on extremely lightweight runtime mechanisms. Examples include the following: (1) basic consistency checks and plausibility filters—such as rejecting readings that violate physical bounds or exhibit implausible transitions—which provide an initial barrier against simple perturbations; (2) ensemble arrangements of very small models (e.g., combining a compact decision tree with a statistical threshold), compelling an attacker to evade multiple independent detectors simultaneously; and (3) the use of hardware-protected execution environments or trusted sensing modules, where supported, to isolate critical detection routines.

By contrast, more capable edge platforms (class 2) can accommodate techniques such as feature squeezing through aggressive input quantization or selectively offloading suspicious samples to a nearby gateway for higher-fidelity inspection. Across these design points, a consistent principle emerges: in constrained IoT settings, low-complexity and deterministic defenses that impose minimal latency and energy cost are often preferable, even when this entails accepting incomplete adversarial robustness in exchange for practical deployability.

In short, adversarial threats change how we should design anomaly detectors: accuracy and efficiency are not enough. The taxonomy’s protection techniques dimension matters because effective models must be built from the ground up to resist adversarial manipulation while still fitting tight IoT resource budgets.

5. Discussion

This review shows that trustworthy IoT requires a shift away from one-off fixes toward integrated architectures where privacy-enhancing technologies (PETs) and anomaly detection (AD) work together. PETs protect data confidentiality and integrity so detection systems can trust their inputs, and AD provides continuous, behavior-based monitoring that catches bypasses, failures, or novel attacks that would otherwise undermine privacy controls. In practice this is a two-way partnership: PETs enhance the reliability of AD by securing its data inputs, while AD ensures the long-term effectiveness of PETs by detecting failures or bypasses.

The literature provides many concrete examples of this synergy. PrivStream [68] uses differential privacy to protect edge data before running on-device ML detection. Federated systems such as IoTREPAIR [107] and DIOT [119] enable collaborative threat detection while keeping raw data local. Other deployments combine strong AEAD ciphers (ASCON/ChaCha20-Poly1305) with lightweight statistical anomaly detectors on edge nodes, creating a defense-in-depth stack that both protects data in transit and watches for sensor tampering or suspicious behavior in real time [51]. While these examples demonstrate practical PET-AD integration, they often represent layering or sequential composition rather than true co-design from first principles. A systematic methodology for ground-up co-design, where privacy and detection mechanisms are jointly optimized from the architecture’s inception, remains largely unexplored, as we elaborate in Section 6.

5.1. Core Tensions in IoT Trustworthiness

Our analysis of the foundational constraints and techniques reveals three central, interconnected tensions that challenge practical IoT security implementations. The first one is between security and resource constraints. Class 0/1 hardware limits (see Section 3.1) force trade-offs: suitable candidates include efficient ciphers like ASCON [48] or ChaCha20-Poly1305 [50], but real-world deployment still bumps into systemic issues. Gateway-centered key management and some PUF-based or layered AES setups create single points of failure [61], and the large number of legacy devices continues to cause operational problems—Mirai exploited default credentials at scale [86], and recent automotive portal flaws show that access control gaps persist [90]. Good algorithms matter, but they will not fix fragmented operations by themselves.

The second tension is privacy versus utility. Privacy-enhancing tools like federated learning protect local data, yet they struggle with device heterogeneity and synchronization in real IoT fleets; multi-party computation can protect data but adds latency and cloud dependence, which break real-time needs [78]. Differential privacy needs careful tuning of the epsilon parameter [75]—too much noise kills detection, too little leaves data exposed. Likewise, blockchain-audited systems [83] maintain privacy through local anomaly detection but incur substantial bandwidth and monetary overhead for transaction logging, further illustrating the cost of verifiable trust. Systems such as PrivStream [68] hit a workable privacy–utility balance for their models, but they do not generalize across environments, which shows the need for more adaptive, context-aware privacy solutions.

The third tension involves rapid innovation against the need for standards. The field is fragmented: many vendors and research projects pursue novel AD algorithms in isolation, which makes integration and large-scale deployment hard (see Section 3.1.3). Our five-dimension taxonomy for anomaly detection (Section 4) helps by forcing choices to be made in context—deployment tier, resource budget, latency needs, protection techniques, and communication limits. The trade-offs are concrete: TEDA [106] delivers extreme efficiency at the cost of adaptability, while autoencoders [126] can boost accuracy but demand more energy. The taxonomy gives a practical path away from one-size-fits-all thinking toward methods chosen for the actual operating context. A synthesis of the quantitative trade-offs between privacy, performance, and resource cost for the core PET and AD techniques reviewed is provided in Supplementary Table S5, illustrating the concrete implications of these tensions.

5.2. Synthesis of Field Maturation and Adversarial Robustness

IoT research is fragmented but progressing. Papers cover everything from lightweight statistical filters and classic one-class detectors to deep learning models and hybrid pipelines that pair on-device preprocessing with cloud analysis [43,131,132]. Recent work is increasingly practical: researchers now factor in device energy, latency, and deployment constraints rather than just chasing isolated metric gains [110,133]. Hajj et al. [72] validated their FL-based IDS on actual Arduino hardware, quantifying how sampling rates affect both detection performance (0.97 recall) and resource consumption—providing concrete guidelines for balancing privacy preservation with operational constraints in real deployments. Still, many studies stay narrow—single devices, single threats, or synthetic datasets—which makes meaningful cross-paper comparison difficult [11].

Adversarial attacks and robustness are also rising concerns. Standard gradient-based and other adversarial attacks show that learning-based detectors break unless robustness is explicitly built in [127,129,134]. Defensive ideas (e.g., quantization-aware defenses, certified bounds, and feature squeezing) look promising but often assume compute and energy budgets that constrained devices do not have [130]. This gap matters because adversarial degradation can weaken both privacy protections and detection in integrated PET–AD systems, so the community needs lightweight, hardware-aware defenses that are provably or empirically robust on embedded platforms [107,123,134].

5.3. Operational Imperatives and Integration Challenges

Real-world breaches repeatedly show that operational failures consistently bypass theoretical defenses. The Jeep Cherokee compromise exploited unsecured interfaces [89], and the ongoing effectiveness of Mirai-style attacks [85] highlights how default credentials remain a live problem [87]. Long-term monitoring efforts, such as Panasonic’s honeypot study [96], further confirm that attackers focus on poorly maintained or unpatched devices. Together, these incidents make it clear that closing operational gaps is at least as important as improving algorithms. Practical controls that address those gaps include the following:

• Dynamic credential management to remove static, factory-default logins.
• Network micro-segmentation to limit lateral movement after a compromise.
• Hardware-enforced trust boundaries (secure elements or PUFs) to reduce the risk of cloned or stolen credentials.

Bringing the technologies we reviewed into real deployments—from lightweight on-device crypto and PUF-based authentication to edge AI inference and blockchain-backed logging—creates real engineering friction that theory often understates. Stacking multiple security services increases CPU, memory, and energy demands, often pushing limited IoT hardware past its capacity. Interoperability is also non-trivial: APIs, data schemas, and lifecycle processes must line up; otherwise you end up with weak, monolithic solutions that are hard to maintain in the field.

5.4. Standardization and Adoption Pathways

This review shows that trustworthy IoT requires security designed together with real operational constraints—a balance rarely achieved in the current literature. Federated learning and lightweight cryptography are useful tools, but deployed on their own they often move problems around rather than solving them. The tensions discussed above point to a clear need for coordinated standardization and practical, field-oriented solutions. Immediate, high-impact actions to prioritize are as follows:

• Certify ASCON as the go-to authenticated encryption primitive for constrained devices, building on its selection as a NIST lightweight AEAD standard; [45]. Consolidating around a recognized primitive will reduce fragmentation and interoperability friction.
• Require hardware-rooted device identities (e.g., PUF-backed identity) to replace hardcoded or default credentials, following designs like PLAKE [55] and SRAM-PUF deployments [56]. This moves identity out of software-only control and reduces credential cloning risks.
• Define and adopt adversarial resilience benchmarks that test systems under realistic, evolving attack models so solutions (including federated learning setups) are validated against the threats that actually degrade deployed systems [107].

These steps feed directly into the research and adoption roadmap in Section 6, providing practical pathways for industry and researchers to move from isolated proofs of concept toward deployable, trustworthy IoT ecosystems.

6. Future Research Directions

The literature shows real progress in individual IoT security components, but their integration into a cohesive, trustworthy system remains elusive. Key tensions—between security, privacy, and resource constraints—keep reappearing. One core problem is that PETs and AD are usually developed as separate layers rather than being co-designed, as discussed in Section 5. Joint optimization frameworks that coordinate detector architectures, quantization, and PET parameters (e.g., DP’s epsilon or FL compression rates) are essential for meeting the strict energy, memory, and CPU constraints of class 0/1 devices [12,18]. For instance, Wang et al. [70] demonstrate such co-design, using mutual information for feature selection to enable a federated DNN that reduces communication overhead while maintaining 99.4% detection accuracy. Concrete research should explore integrated micro-architectures, such as a “Privacy-Aware Feature Scheduler” that dynamically selects between raw, differentially private, or homomorphically encrypted data streams for anomaly detection based on a real-time energy–privacy budget. Another direction is hardware–software co-design of a “TinyCrypt-Detector” co-processor, sharing logic between ASCON AEAD operations and statistical feature extraction to minimize area and power overhead. This line of inquiry directly addresses gap 1 (co-design shortage) by creating unified systems and gap 2 (inconsistent trade-off reporting) by making the privacy–energy–accuracy trade-off a tunable, measurable parameter of the architecture. Adopting a co-design perspective facilitates the balancing of privacy, utility, and resource constraints.

Concurrently, the energy–security paradox demands new runtime strategies. Security mechanisms can consume a very large share of a device’s power budget [18], so architectures must adapt: scale cryptographic strength (ASCON [48] or ChaCha20-Poly1305 [50]) and detection complexity based on current battery state and assessed threat level. This requires energy-aware scheduling in distributed schemes such as federated learning so participant selection preserves the global model without compromising the integrity—a challenge noted in [71]. A promising hybrid architecture to embody this is an “Adaptive PET-AD Mesh.” In this design, a local cluster of heterogeneous devices is orchestrated by a designated, slightly more capable “lead node.” This lead node performs energy-aware participant selection for FL, aggregates locally generated DP-noised anomaly alerts, and interfaces with a lightweight blockchain ledger for tamper-evident logging of critical events, distributing trust and computational load efficiently. This hybrid design tackles gap 3 (robustness against adaptive attackers) through distributed trust and layered defenses, while its energy-aware scheduling mechanism provides a concrete framework for reporting resource trade-offs (gap 2). We also need lightweight, hardware-aware defenses against adversarial attacks (e.g., quantization-aware adversarial training [130] and feature squeezing [129]) so robustness measures actually fit on microcontrollers.

Legacy devices make the problem systemic rather than academic. Mirai-style botnets [85,87] and massive breaches [95] show that billions of poorly maintained units are a continuing threat. Research should prioritize secure retrofitting: hardware–software co-designs that add hardware-rooted trust (PUFs) while using federated methods to refresh entropy and manage aging [55,56]. Pair those ideas with blockchain-anchored, integrity-checked OTA updates to block firmware tampering and aim for backward-compatible approaches that work across heterogeneous fleets. A tangible research artifact to this end is a “Security Proxy Dongle”—an external module equipped with a PUF and secure element that attaches to legacy sensors via UART or GPIO. This dongle is intended to encrypt local data, execute a minimal anomaly detection technique, and mediate secure over-the-air (OTA) updates for the host device. The principal research challenge is the design of a reliable, zero-touch bootstrapping protocol that can autonomously establish mutual trust among the dongle, legacy endpoint, and network gateway. Framed as a retrofit strategy, this approach addresses gap 3 (protecting vulnerable legacy systems from adaptive attacks) and exemplifies the co-design principle (gap 1) by combining dedicated security hardware with existing software stacks. To reduce reliance on centralized authorities—and thereby avoid well-documented Private Key Generator (PKG) weaknesses in Identity-Based Cryptography [59]—we propose investigating a hybrid of hardware-rooted identifiers (e.g., dual-PUF mechanisms [57]) and sharded blockchain ledgers to support scalable, device-to-device authentication without continuous cloud dependence [27,28]. While promising, this direction must contend with practical constraints such as PUF stability, ledger overhead, and interoperability with legacy platforms.

Our taxonomy (Section 4) also reveals a blind spot: memory constraints during model training are often ignored. Many studies optimize only inference (see [106,126]), which misses SRAM and training time constraints on MCUs. TinyML pipelines should therefore include quantization-aware SVM training with overflow guards—building on Edge2Train’s energy wins while addressing memory safety [101]. Unsupervised models like TEDA [106] require systematic, cross-environment benchmarking against the taxonomy’s resource dimension so we can compare adaptability as well as raw efficiency. To systematically address this, the community needs an open-source benchmark framework that profiles not just inference but training-phase memory peaks, energy per epoch, and adversarial robustness for TinyML models on popular MCUs. This framework should operationalize the multi-dimensional taxonomy from Section 4, forcing evaluations to report across deployment, resource, and protection axes, thereby creating comparable data to guide architecture choices. This benchmarking initiative is fundamental to closing gap 2 (inconsistent reporting) by standardizing metrics and gap 3 (robustness) by mandating evaluation under adversarial and noisy conditions.

The field clearly needs common benchmarks and reporting practices. Right now papers measure different things in different ways, which blocks reproducibility and meaningful comparison across sensor-to-cloud stacks (Section 3 and Section 4). Future work must develop end-to-end benchmarks that jointly evaluate detection performance, privacy leakage, energy use, and latency under realistic deployment conditions, including factors such as sensor drift, network variability, and adaptive adversaries. Metrics like “cryptographic bit-strength per joule” or “detection accuracy under a specified DP epsilon” would make evaluations comparable and help push the community from isolated prototypes toward deployable systems. Establishing such benchmarks is a necessary precursor for meaningful quantitative meta-analyses that could compare normalized metrics—such as energy cost per detection, accuracy under privacy constraints, or latency–security trade-offs—across diverse approaches.

To bridge the co-design gap identified in this review, we propose a systematic framework for integrating PETs and AD from initial conception through deployment. Building on the integration patterns observed in existing work—such as PrivStream’s DP-enhanced detection [68], IoTREPAIR’s federated anomaly hunting [107], DIOT’s communication-optimized GRU networks [119], Antonini et al.’s blockchain-audited TinyML system [83], Hajj et al.’s cross-layer federated k-means [72], Wang et al.’s feature-selected federated DNN [70], and Serban et al.’s combined encryption–detection stack [51]—this framework consists of four iterative phases with concrete design considerations.

The first phase involves joint requirement specification and threat modeling, where privacy guarantees, detection requirements, and resource constraints are defined simultaneously. This extends beyond the sequential approach seen in current deployments by requiring that privacy parameters, detection accuracy targets, and hardware limitations be optimized jointly rather than sequentially.

The second phase focuses on unified algorithm selection and compatibility analysis, moving beyond the layered compositions common in existing work. Rather than retrofitting PETs atop existing detectors, this phase selects detection algorithms inherently compatible with chosen PETs—such as noise-robust models for DP or communication-efficient architectures for FL—as suggested by the optimizations in DIOT [119] and Edge2Train [101] and the cross-layer FL approach of Hajj et al. [72]. Wang et al.’s [70] work exemplifies this through mutual information feature selection that enables federated deep learning with minimal communication overhead.

The third phase involves cross-layer resource sharing and optimization, identifying opportunities to share computations, memory, and communication between PET and AD components. This goes beyond the defense-in-depth stacking seen in current deployments [51] by seeking unified execution paths where cryptographic operations directly inform detection features and vice versa. For instance, Antonini et al.’s [83] system shares the same ESP microcontroller for both TinyML inference and blockchain transaction signing, optimizing memory usage to just 84KB for real-time anomaly detection.

Finally, the fourth phase requires integrated validation and trade-off characterization, developing comprehensive metrics that simultaneously measure privacy-loss budget versus detection performance degradation, energy consumption per private detection event, and end-to-end latency. While IoTREPAIR [107] begins to approach this through multi-dimensional evaluation, the studies analyzed in this review—including [70,72,83]—demonstrate varying approaches to reporting these critical trade-offs, highlighting the need for a standardized assessment framework.

This structured methodology provides concrete guidance for evolving from the layering and sequential integration observed in current deployments toward truly co-designed systems where privacy and detection are mutually reinforcing and collectively optimized from the ground up for constrained IoT environments.

7. Conclusions

This review examined the evolving landscape of security and privacy for resource-constrained IoT systems and argued that isolated measures rarely provide robust protection in practice. Effective defenses instead arise from integrating privacy-enhancing technologies (PETs) with anomaly detection (AD): PETs reduce exposure of sensitive inputs and preserve confidentiality, while AD supplies continuous, behavior-based monitoring that uncovers misconfiguration, bypasses, or novel attack patterns that would otherwise invalidate privacy assumptions.

Our primary contribution is a practical, multi-dimensional taxonomy for anomaly detection that organizes design choices along five actionable axes: deployment paradigms, resource constraints, real-time requirements, protection techniques, and communication constraints. The taxonomy is meant to guide concrete trade-offs and to highlight how PET and AD decisions interact in deployment.

Despite advances in lightweight algorithms and distributed intelligence, key bottlenecks persist: fragmented protocols and vendor-specific implementations, scalability and latency limitations in federated or blockchain approaches, and large fleets of legacy devices that are difficult to retrofit. Several incidents illustrate that theoretical guarantees alone do not ensure operational resilience. To systematically overcome these barriers, the research roadmap in Section 6 provides a targeted strategy to address each of the three core gaps identified in our analysis.

Gap 1, concerning the lack of co-design, is addressed through the use of integrated micro-architectures together with a structured, four-phase co-design methodology. To respond to gap 2, which relates to inconsistent reporting practices, we propose embedding instrumentation that enables real-time monitoring of design trade-offs and adopting open-source benchmarking frameworks that require multi-dimensional evaluation. Gap 3, the limited robustness of existing systems, is approached through distributed trust architectures, hardware-based retrofit mechanisms, and explicit benchmarking requirements for adversarial testing. By mapping each line of research to its corresponding deficiency, the roadmap seeks to provide a coherent progression from identified limitations to implementable solutions.

Translating this roadmap into practice requires pragmatic standardization—lightweight AEAD cryptography, hardware-rooted authentication, and shared benchmarks that jointly measure security, privacy leakage, energy, and latency on representative constrained hardware.

Looking forward, research should prioritize co-design, energy-aware scheduling, and adversarial robustness tailored to tiny/quantized models: jointly tuning detectors, quantization, and PET parameters within hard resource budgets; runtime adaptations that trade privacy, accuracy, and latency; and lightweight defenses appropriate for constrained devices. Supported by open benchmarks and interoperable standards, these directions make PET–AD integration a realistic path to trustworthy IoT systems in healthcare, industry, and other critical domains.