💻 computer science

A Privacy-Preserving Federated Intrusion Detection Framework with Reputation-Aware Client Selection and Integrity Verification

This paper proposes a privacy-preserving federated intrusion detection framework for Industrial Internet of Things networks that utilizes client-level DP-SGD, hashing for integrity, and a lightweight reputation-based client selection mechanism to achieve over 98% accuracy in non-IID environments without sharing raw data.

Original authors: Mahdiyeh Velaei, Mehdi Aminian, Seyyed Amir Asghari, Mohammad Faraji-Mehmandar

Published 2026-08-11

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Mahdiyeh Velaei, Mehdi Aminian, Seyyed Amir Asghari, Mohammad Faraji-Mehmandar

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the internet as a giant, bustling city where billions of tiny devices—smart thermostats, factory robots, and self-driving cars—constantly chatter with each other. This is the Industrial Internet of Things (IIoT). While this city is amazing, it's also a magnet for digital burglars trying to crash the grid or steal secrets. To stop them, we need "security guards" (Intrusion Detection Systems) that can spot bad actors instantly. Traditionally, these guards worked by gathering every single piece of data from every device and sending it to one giant, central headquarters to be analyzed. But this is like asking every citizen to mail their entire diary to the mayor; it's slow, clogs the roads, and is a massive privacy nightmare.

Enter Federated Learning, a clever new way of doing things. Instead of mailing diaries, the devices keep their data at home. They train a small "security guard" model locally, learn from their own experiences, and then just send a tiny summary of what they learned (the "weights" of the model) to the central server. The server mixes these summaries to create a smarter, global guard, without ever seeing the private data. However, this system has a few glitches: what if a device is lying about what it learned? What if the data at different factories is so different that the models get confused? And how do we make sure no one is peeking at the summaries? This paper tackles those exact problems, proposing a system that keeps data private, checks for liars, and works even when the data is messy and uneven.

The "Honest-but-Curious" City Guard

The researchers behind this study, Mahdiyeh Velaei and her team, built a digital fortress designed for the messy, chaotic reality of industrial networks. They call their creation a Privacy-Preserving Federated Intrusion Detection Framework. Think of it as a neighborhood watch program where every house has its own security camera, but instead of streaming video to a central station (which would be a privacy disaster), each house analyzes its own footage and only sends a "report card" to the neighborhood captain.

The big challenge they faced was the "Non-IID" problem. In the real world, not all devices see the same things. A factory robot in a car plant sees different traffic patterns than a sensor in a power grid. It's like asking a group of students to solve a math problem, but some have textbooks on algebra, others on geometry, and a few have blank pages. If you just average their answers, you might get nonsense. The authors used a mathematical tool called a Dirichlet distribution to simulate this messy reality, ensuring their system could handle data that was unevenly scattered across 3, 5, or 7 different "clients" (devices).

The "Reputation Score" and the "Hash Check"

To keep the system safe from bad actors, the authors introduced two main defenses, which they describe as a "Reputation-Based Authority" and "Integrity Verification."

Imagine the central server as a strict teacher grading homework. In the past, the teacher might have just trusted every student who raised their hand. But in this new system, the teacher keeps a Reputation Score for every student.

The Green Zone: If a student (client) submits good homework quickly and accurately, their reputation goes up. They get to keep participating.
The Red Zone: If a student is slow, unresponsive, or submits gibberish (which could be a malicious attack), their reputation drops. If it gets too low, they are kicked out of the class for a few rounds.
The Mechanism: This isn't a complex blockchain (which would be like building a massive, slow ledger for every pencil mark). Instead, it's a lightweight, smart system that looks at two things: how good the model is (measured by an F1 score, a balance between catching bad guys and not crying wolf) and how fast the student was. The system dynamically adjusts how much it cares about speed versus quality depending on how chaotic the current round is.

But what if a bad actor tries to sneak in a fake report card? That's where the Hash Verification comes in. Think of a hash as a unique digital fingerprint. Before a student sends their report, they stamp it with a special seal (using SHA-256). When the teacher gets it, they re-calculate the fingerprint. If even one tiny letter is changed, the fingerprint won't match, and the report is instantly rejected. This ensures that no one can tamper with the data on its way to the server, all without needing heavy, slow encryption.

The "Noise" Shield

To protect privacy even further, the team used Differential Privacy (DP). Imagine the students are whispering their answers to the teacher. To make sure no one can guess exactly what a specific student wrote, the teacher adds a little bit of static noise to the whispers. It's just enough to hide the individual details but not so much that the overall message gets lost. The researchers found a sweet spot: they added enough noise to make it very hard to steal private data, but not so much that the security guard stopped working.

The Results: A Near-Perfect Scorecard

The team tested their system using the Edge-IIoTset dataset, a massive collection of real-world network traffic containing over 2.2 million records of both normal activity and cyberattacks. They ran simulations with 3, 5, and 7 clients in both "binary" (Is it an attack? Yes/No) and "multi-class" (What kind of attack is it?) scenarios.

The results were impressive. In the binary scenario (just spotting if an attack is happening), the system achieved an accuracy of 99.77% with 3 clients and 99.06% with 7 clients. Even in the trickier multi-class scenario (identifying specific attack types), it maintained high accuracy, reaching 98.61% with 3 clients.

Perhaps most importantly, the system handled the "messy" data well. While one specific scenario with 5 clients showed a slight dip in performance (dropping to 96.85% in binary detection), the system generally converged quickly and remained stable. The "Total Latency" (how long it took to train) was also reasonable, with the system showing that adding more clients helped distribute the work, making the whole network faster and more stable.

What This Means

The authors are careful to note that this is a simulation. They haven't built a physical factory with robots yet; they ran these tests on a powerful computer using a standard dataset. However, the simulation suggests that you don't need a massive, expensive blockchain infrastructure to secure your network. By combining a smart reputation system, a simple fingerprint check (hashing), and a little bit of privacy noise, you can build a security system that is fast, private, and surprisingly accurate.

In a world where our devices are constantly under siege, this paper offers a blueprint for a defense system that respects privacy, weeds out the unresponsive or malicious, and learns from the chaos of the real world—all without ever needing to see your private data. It's a step toward a future where the internet's security guards are smart, fair, and keep your secrets safe.

Technical Summary: A Privacy-Preserving Federated Intrusion Detection Framework with Reputation-Aware Client Selection and Integrity Verification

1. Problem Statement

The rapid expansion of Industrial Internet of Things (IIoT) networks has increased the vulnerability of critical infrastructure to cyberattacks. Traditional centralized Intrusion Detection Systems (IDS) face significant challenges, including data privacy concerns, high communication overhead, and bottlenecks caused by transmitting raw data to a central server. Furthermore, existing Federated Learning (FL) approaches often struggle with:

Non-IID Data: Real-world IIoT environments exhibit heterogeneous data distributions across nodes, leading to model divergence and slow convergence.
Security Vulnerabilities: FL systems are susceptible to malicious clients injecting poisoned updates, data leakage, and model tampering.
Lack of Trust Mechanisms: Many frameworks assume honest client behavior, failing to account for nodes with poor performance or malicious intent in decentralized environments.
Privacy-Utility Trade-off: Implementing strong privacy measures (like Differential Privacy) often degrades model accuracy, a critical issue for intrusion detection.

2. Methodology

The authors propose a secure, privacy-preserving FL framework designed specifically for IIoT environments. The architecture integrates four core components:

A. Local Model and Privacy Preservation

Model Architecture: Each client trains a lightweight Multi-Layer Perceptron (MLP) locally. The network consists of three hidden layers (128, 64, 32 neurons) with ReLU activation and Dropout to prevent overfitting.
Differential Privacy (DP): To protect local data, the framework employs DP-SGD. Per-sample gradients are clipped to a threshold ( $C$ ), and Gaussian noise is added during aggregation. The noise multiplier is tuned empirically (1.0 for binary, 0.5 for multi-class) to balance privacy and utility.
Non-IID Simulation: Data is distributed among clients using a Dirichlet distribution ( $\alpha=0.5$ ) to simulate realistic, heterogeneous IIoT conditions.

B. Integrity Verification (Hash-Based)

Mechanism: To ensure updates are not tampered with during transmission, the framework uses a lightweight hash-based verification system rather than a full blockchain or Public Key Infrastructure (PKI).
Process:
1. Clients serialize model updates and generate a SHA-256 hash.
2. A validation token is created using the client's encrypted ID and the hash.
3. The server recalculates the hash and token. If they match the received values, the update is accepted; otherwise, it is rejected.

C. Reputation-Aware Client Selection (PoA-Inspired)

Concept: Inspired by "Proof of Accuracy" (PoA) in blockchain, but implemented without a full consensus mechanism. A central server dynamically evaluates client trust.
Scoring Criteria: A reputation score ( $R_k$ $R_{k}$ ) is calculated based on:
- Quality: The local $F1_{score}$ of the client's model.
- Latency: The total time taken for training and communication ( $T_{train} + T_{comm}$ ).
Dynamic Weighting: The weights for quality and latency are adjusted dynamically based on the variance of these metrics across participating clients in each round.
Incentive/Penalty System:
- Green Zone ( $R_k \geq 0.75$ ): Trusted clients are rewarded (score increases).
- Normal Zone ( $0.5 < R_k < 0.75$ ): No change.
- Red Zone ( $R_k \leq 0.5$ ): Clients are temporarily excluded (2 rounds) and penalized. Persistent low scores lead to permanent exclusion.
Aggregation: Only selected clients participate in the standard FedAvg aggregation.

D. Data Preprocessing

The framework utilizes the Edge-IIoTset dataset. A rigorous preprocessing pipeline is applied, including:

Removal of non-predictive features (IPs, IDs).
Conversion of raw packets to flow-based representations.
Statistical extraction of payload features (e.g., Shannon entropy).
One-Hot Encoding and Min-Max normalization.
Handling of class imbalance and data cleaning.

3. Key Contributions

Integrated Framework: A unified architecture that simultaneously addresses privacy (DP), integrity (Hash verification), and stability (Reputation-based selection) in non-IID IIoT environments.
Lightweight Trust Mechanism: A PoA-inspired client selection strategy that manages malicious or low-quality nodes without the computational overhead of a full blockchain implementation.
Dynamic Reputation Scoring: A self-adjusting weighting system that prioritizes either model quality or latency based on the current dispersion of client performance, ensuring adaptability to changing network conditions.
Comprehensive Evaluation: Extensive testing on the Edge-IIoTset dataset across binary and multi-class scenarios with 3, 5, and 7 clients, demonstrating robustness under Non-IID conditions.

4. Experimental Results

The framework was evaluated on the Edge-IIoTset dataset (2.2M+ records) using 3, 5, and 7 clients over 10 communication rounds.

Accuracy: The model achieved high accuracy across most scenarios, though performance varied by configuration:
- Binary Classification: Ranged from 96.85% (5 clients) to 99.77% (3 clients). The 5-client scenario exhibited significantly lower accuracy and recall (94.09%) compared to other configurations, attributed to data heterogeneity.
- Multi-class Classification: Ranged from 97.19% (7 clients) to 98.61% (3 clients).
- While the 3 and 7-client scenarios approached centralized learning performance (98.87% binary, 99.95% multi-class), the 5-client binary scenario showed distinct weaknesses with lower accuracy (96.85% vs 98.87%).
Convergence: The model demonstrated rapid convergence in most cases. The 5-client binary scenario showed higher loss and lower recall, indicating challenges with data heterogeneity in that specific setup, while 3 and 7-client scenarios showed stable convergence with low loss.
AUC and F1-Score:
- AUC values approached 1.0 in most multi-class scenarios, indicating excellent class separation.
- F1-scores remained above 96% in all experiments, balancing precision and recall effectively.
Latency: The reputation mechanism introduced dynamic fluctuations in latency (due to client exclusion), but the system maintained stability. Increasing the number of clients (from 3 to 7) generally reduced average latency by better distributing the computational load.

5. Significance and Claims

The paper claims that its primary significance lies in providing a balanced framework that does not sacrifice model utility for security or vice versa.

Practicality: By avoiding full blockchain infrastructure and complex consensus mechanisms, the solution is deployable in resource-constrained IIoT environments.
Robustness: The combination of extensive data preprocessing, DP, and reputation-based selection allows the system to maintain high detection accuracy (96–99%) in most scenarios, even in the presence of non-IID data and potential malicious nodes, though specific configurations (like 5 clients in binary mode) showed reduced performance.
Privacy-Utility Balance: The authors assert that their tuning of DP parameters achieves a "practical balance," preserving local data confidentiality while limiting the negative impact on detection accuracy, a critical requirement for real-world industrial applications.

The authors conclude that while the current implementation focuses on data quality and client trust, future work will explore resource-aware client selection (considering energy and processing power) and adaptive aggregation methods based on real-time security risks.