The rapid proliferation of IoT technologies has fundamentally reshaped smart infrastructures, from domestic applications to complex industrial systems. However, this layered and geographically distributed architecture introduces multifaceted security challenges, particularly in identifying coordinated or stealthy threats that propagate across diferent levels of the system. Traditional intrusion detection systems (IDS), typically deployed in isolation, either at the edge or within the cloud, struggle to achieve the necessary global visibility and often exhibit delayed responsiveness in such dynamic environments. In this paper, we propose a novel vertical intrusion detection framework tailored to multi-layered IoT networks. Our system enables hierarchical correlation and fusion of alerts across edge, fog, and cloud layers by combining localized anomaly detection with a global graph neural network (GNN) that performs structural and temporal reasoning over an alert graph. To ensure robustness in adversarial settings, we introduce an evolutionary game-theoretic mechanism based on replicator dynamics, which dynamically adjusts the trust levels of inter-node connections. The nodes evaluate the reliability of their neighbors based on accuracy and detection consistency, leading to reinforcement of cooperative behaviors and marginalization of compromised participants. Experimental results show that our architecture improves detection performance, reduces false positives, and adapts efectively to changing threat landscapes.
The proliferation of the Internet of Things (IoT) has profoundly transformed the technological landscape,
allowing traditional infrastructures to evolve into smart, interconnected ecosystems. From smart homes
and telemedicine to industrial automation and intelligent transportation systems, IoT technologies are
now the foundation for critical services across a wide range of sectors. These environments typically
rely on a multi-layered architecture comprising edge devices, fog nodes, and centralized cloud platforms.
This hierarchical structure allows the system to balance trade-ofs between latency, computational
resources, and storage capabilities [
However, this layered architecture also introduces complex security challenges. The distributed
nature of IoT leads to fragmented local observations, often limited in scope and granularity, which
can hinder accurate and timely threat detection. Particularly concerning are coordinated and stealthy
attacks that exploit the lack of global visibility. An adversary may launch seemingly benign activities at
various layers, such as low-frequency anomalies at the edge or subtle misconfigurations at intermediate
fog nodes, which appear innocent in isolation but, when viewed holistically, reveal a sophisticated
attack pattern [
To overcome these limitations, we propose a new Vertical Intrusion Detection System (V-IDS) that is natively designed for the layered nature of IoT infrastructures. Our contributions are threefold: • We introduce a graph neural network (GNN)-based fusion architecture that enables the aggregation and correlation of alerts across the vertical layers of the IoT stack. This design supports both structural and temporal reasoning, allowing the system to detect distributed and evolving attack patterns that would remain hidden in layer-isolated analyzes. • We incorporate an evolutionary game-theoretic mechanism based on replicator dynamics to continuously adjust the influence (edge weights) of participating nodes within the GNN. This mechanism evaluates the historical performance and consistency of each node, reinforcing contributions from reliable agents while gradually reducing the impact of untrustworthy or compromised participants. • We demonstrate that the proposed system significantly improves detection performance and resilience through extensive simulations. Our results highlight the advantages of combining hierarchical alert fusion with trust-based adaptive reasoning under adversarial conditions.
By integrating multi-layered visibility with adaptive trust modeling, V-IDS ofers a scalable and robust solution for intrusion detection in complex and dynamic IoT environments. Addresses key limitations of existing systems by enabling global threat inference from fragmented and potentially unreliable local data, a crucial step toward securing the next generation of smart infrastructures.
Intrusion detection systems are essential for monitoring and detecting malicious activity in networked
environments [
In the context of IoT, these traditional IDS approaches face significant limitations. IoT environments
are characterized by high device heterogeneity, resource constraints, and decentralized architectures.
Several works have proposed lightweight or distributed IDS for edge or fog computing layers [
Graph-based learning has emerged as a powerful paradigm in intrusion detection, particularly with the adoption of Graph Neural Networks (GNNs) due to their ability to model structured data, such as communication graphs, process dependency graphs, and interaction networks. GNNs enable the propagation and aggregation of information across connected entities, making them well-suited to capture the relational patterns and spatial correlations inherent in networked systems.
In the context of IDS, GNNs have been applied to various tasks: GCN-IDS [
Despite their efectiveness, most of the existing GNN-based IDS approaches sufer from structural limitations. They often assume a static, centralized, or flat topology, which does not reflect the layered and distributed nature of modern IoT environments. Node interactions are typically assigned uniform or ifxed edge weights, without taking into account dynamic trust levels or reliability, limiting the system’s ability to adapt to adversarial conditions.
Moreover, few existing approaches explicitly address the vertical nature of IoT architectures,
where alert signals and contextual information flow from edge devices to fog nodes and cloud services.
Without modeling this hierarchical structure and the corresponding dependencies between layers, such
systems lack the ability to perform holistic threat reasoning and struggle to maintain robustness in
the face of distributed, stealthy, or coordinated attacks [
Trust-aware computing and dynamic weighting have been explored in distributed systems to mitigate
the influence of unreliable nodes. Reputation-based schemes and credibility scores have been used in
wireless sensor networks and federated learning [
However, these mechanisms are often implemented outside of the learning process (e.g., pre-filtering nodes), or rely on global reputation tracking, which is impractical for dynamic, large-scale IoT settings. Very few works incorporate local, adaptive trust mechanisms directly into the message-passing operations of a GNN for intrusion detection.
The existing literature on intrusion detection in IoT environments highlights several important limitations. First, most IDS solutions do not take advantage of the inherent vertical structure of IoT architectures. Rather than leveraging the hierarchical organization of edge, fog, and cloud layers for multi-level reasoning, they often operate in a flat or isolated manner, limiting their capacity to detect complex, multi-stage threats. Second, graph-based approaches, including those based on Graph Neural Networks, generally rely on fixed edge weights and lack mechanisms to adapt to dynamic variations in node behavior or reliability. This static configuration renders them vulnerable in adversarial or noisy environments. Finally, while trust and reputation mechanisms have been studied in distributed systems, they are typically implemented externally to the learning model and rarely integrated into the core inference process of the IDS itself. In particular, to our knowledge, no existing approach incorporates localized evolutionary trust dynamics directly within the GNN message-passing framework.
In this work, we address these limitations by introducing a novel vertical IDS framework tailored to the hierarchical structure of IoT environments. Our approach performs multi-layered alert fusion via a graph neural network architecture that explicitly encodes the vertical communication pathways from edge to cloud. Unlike prior work that relies on static topologies and uniform weighting, we incorporate a dynamic, trust-aware weighting mechanism based on local evolutionary dynamics inspired by game theory. This mechanism enables each node to adjust the inuflence of its neighbors based on observed behavior over time, enhancing resilience to malicious or unreliable participants. As a result, our system can correlate fragmented and partial observations across diferent layers, suppress the propagation of misleading information, and maintain robustness against distributed and adaptive adversaries.
We consider a three-tier IoT architecture composed of layers edge, fog, and cloud. Edge devices resides closest to the physical environment: sensors, actuators, and user endpoints that collect raw telemetry
Cloud Data Center
Fog Nodes (Domain Aggregators) Edge Devices (Sensors / Endpoints) and perform low-latency processing under constrained resources. Fog nodes, positioned between the edge and the cloud, serve as domain-level aggregators; they consolidate data from multiple edge devices, apply pre-processing and filtering, and enforce localized policies to reduce both latency and upstream trafic. The cloud layer ofers elastic compute and storage across domains, maintains a long-term context, and executes global-scale analytics and learning models.
This vertical architecture is depicted in Figure 1, which highlights the bidirectional flow of information: uplink telemetry and alerts (solid arrows) propagate from edge to fog to cloud, while feedback, updated models and enforcement policies flow downstream.
Within this hierarchical structure, observations are inherently fragmented: edge nodes detect finegrained but localized patterns; fog nodes uncover domain-level correlations; the cloud synthesizes cross-domain signals into global insights. Our IDS design takes advantage of this vertical segmentation in two synergistic ways. First, each tier performs an adaptive trust assessment by monitoring the consistency and quality of the alerts received from the tier below, adjusting its attention to upstream sources via an evolutionary weighting mechanism. Second, the cloud fuses multi-tier summaries using graph-based message passing within a GNN, enabling global threat detection through the integration of multi-hop, multi-layer dependencies otherwise undetectable by isolated nodes.
Evolutionary Game Theory (EGT) emerged in the 1970s to explain adaptation in large populations [
Consider a finite set of pure strategies = {1, . . . , }. A population state is a vector = the strategy . against population is ↦→ ( 1(), . . . , ()). to payof diferences: (1, . . . , ) in the probability simplex ∆ − 1 = { ∈ R≥0 : ∑︀ = 1}, where is the frequency of In a symmetric two-player game with payof matrix ∈ R× , the (expected) fitness of strategy () = (),
¯( ) = ⊤ (mean fitness) .
More generally, in a population game, one specifies a continuous fitness map
: ∆ − 1
→ R,
Replicator dynamic [
︀( ())︀ ∑︀ () ︀( ())︀ , which is the discrete analogue of the replicator flow.
A state * is a (symmetric) Nash equilibrium if every strategy in its support achieves maximum payof: for all with * > 0 and all , (* ) ≥ (* ). All Nash equilibria are stationary for the replicator dynamic (̇ = 0), although not all stationary points are Nash.
and is resistant to invasion: there exists 0 > 0 such that for any ̸= * and all 0 < < 0,
A state * ∈ ∆ − 1 is an ESS if it is a Nash equilibrium (︀ * , (1 − )* + )︀ > (︀ , (1 − )* + )︀ , i.e., the incumbent earns strictly higher payof than any nearby mutant when the population is mostly at * . In symmetric matrix games, the asymptotically stable rest point of the replicator dynamic; conversely, asymptotic stability of the replicator implies a refinement of Nash that excludes neutrally stable points (non-ESS).
Under replicator flow, the mean fitness
¯( ) is a Lyapunov function for potential games, and the
dynamics is gradient-like with respect to the Shahshahani metric [
with an input vector of characteristics ∈ R0 and a representation ℎ network, initialized as ℎ(0) = . We denote the in-neighborhood of node by Let = (, ℰ ) be a directed graph, where is the set of nodes, with || = , and ℰ ⊆ × of directed edges (that is, ordered pairs (, ) with an edge from to ). Each node ∈ is associated is the set (ℓ)
∈ Rℓ in the layer ℓ of the () = { ∈ | (, ) ∈ ℰ }, state: i.e., the set of nodes with edges directed toward .
A Graph Neural Network iteratively updates node representations through message passing over . At each layer ℓ, a node receives messages from its neighbors (), aggregates them, and updates its ℎ(ℓ+1) = (ℓ) ⎛ ⎝ℎ(ℓ),
⨁︁ (ℓ)(︁ ℎ
where (ℓ) is a message function, (ℓ) an update function, optional edge features, and ⊕ a
permutation-invariant aggregator (for example, sum or mean) [
A common instance is the Graph Convolutional Network (GCN), which uses linear messages and symmetric normalization.
(ℓ+1) = ︁( ˜− 1/2˜˜− 1/2 (ℓ) (ℓ))︁ , where ˜ = + is the adjacency matrix with self-loops, ˜ its degree matrix, (ℓ) the characteristics of the nodes in the layer ℓ, (ℓ) a learnable weight matrix and an activation function (for example, ReLU). This formulation ensures that each node combines its own features and those of its neighbors in a normalized way.
Weighted aggregation. In settings where edges carry reliability scores ∈ [
(ℓ+1) = ︁( ˆ− 1/2ˆ()ˆ− 1/2 (ℓ) (ℓ))︁ , where ˆ() = () + and ˆ = diag(ˆ()1).
Alternatively, we can row-normalize weights per target node:
˜ = ∑︀∈ () + , ⎛
⎞ ℎ(ℓ+1) = ⎝0ℎ
(ℓ) +
∑︁ ˜ ℎ(ℓ)⎠ , which makes the propagation scale invariant and interpretable as a reliability-weighted attention.
These weights can be learned (as in attention mechanisms) or externally provided, e.g., based on past performance, trust levels, or cross-layer confirmation. In our case, they are computed independently and used to modulate the information flow across the graph.
Although the concept of a multilayered IDS architecture has been outlined, the present study deliberately focuses on a two-layer Fog–Cloud model, which is suficient to validate the concepts introduced while maintaining analytical tractability and facilitating simulation. Extending this framework to a threelayer Edge–Fog–Cloud architecture is feasible, for instance, by adopting a GNN-based approach in which nodes are organized into clusters forming subgraphs. In this structure, intra-cluster edges capture interactions among edge nodes, while inter-cluster edges represent interactions at the Fog level. However, such an extension would introduce additional complexity in the IDS design, which requires coordinated detection between edge, fog, and cloud nodes, along with increased computational overhead. This avenue will be explored in future work.
We consider a hierarchical IoT architecture composed of three layers: edge, fog, and cloud. Edge devices generate raw data, but lack the capacity for local intrusion analysis. Each fog node supervises a subset ℰ of edge devices and runs a lightweight intrusion detection module. Detected anomalies are forwarded to the cloud layer for further analysis.
At the cloud level, alerts are jointly analyzed using a GNN, where nodes represent fog entities, and edges encode their proximity. This enables the detection of coordinated or distributed intrusions by leveraging spatiotemporal dependencies.
To enhance robustness against unreliable or compromised fog nodes, we propose a vertical intrusion detection system that integrates two-level detection and trust feedback. Local fog detection is complemented by global cloud analysis, where trust scores are dynamically adjusted to reinforce reliable sources and downweight inconsistent ones.
The general architecture of our vertical intrusion detection system is illustrated in Figure 2. It shows the two-layer detection flow from edge to cloud, as well as the integration of spatio-temporal analysis and trust-based feedback.
Sensors, cameras, or smart IoT Devices generating events, …
Local IDSs Local anomaly detection
and alert generation Collected traffic features
Aggregated alerts and feedback
Edge Devices (Sensors / Endpoints)
Fog Nodes (Domain Aggregators)
Trust scores / strategies update
Trust-based payoff computation Evolutionary Game
Module Evaluates feedback trustworthiness via evolutionary game
Graph Module {Intrusion ,Benign} Constructs global attack correlations from local observations
In the fog layer, each node is responsible for monitoring a subset of edge devices ℰ and detecting signs of potential intrusions. Due to resource constraints, only lightweight analysis is performed locally. Rather than transmitting raw alerts to the cloud, each fog node computes a set of structured metrics designed to summarize the security context of its monitored region. These metrics form the basis for later global analysis and trust computation.
Let denote the current detection time window. Each fog node is responsible for monitoring a set of edge devices ℰ. During window , the node collects a set of raw detection events: () = {1, 2, . . . , }, where is the number of events detected by the fog node during the time window , and each event originates from some device in ℰ. For each event , the fog node extracts a local feature vector x ∈ R, where denotes the number of detection-relevant attributes. These features typically include metrics such as anomaly score, packet rate variance, source IP entropy, protocol distribution, and flow duration.
To summarize its local detection activity, each fog node computes the following aggregated metrics on ():
• Anomaly intensity — average anomaly score across events:
denotes the anomaly score of event , extracted as a component () =
1 ∑︁ , =1 of the feature vector x .
=1 ∑︁ log , • Event diversity — Shannon entropy over the distribution of event types: () = −
where is the number of distinct event types observed in (), |ℰ| · among the events in (). and is the proportion of events of type . Each event is labeled with a type (e.g. port scan, login attempt), and the proportions {}=1 are estimated by counting the frequency of each type • Temporal dispersion — standard deviation of interarrival times:
︁( ∆ () = std {(+1) − }=1 − 1︁) ,
where is the timestamp of event , order of their timestamps.
and std(· ) denote the standard deviation. Events { } are assumed to be sorted in increasing • Detection rate — number of events per device per time unit: () = ,
where is the number of events in (), |ℰ| is the number of devices , monitored by and is the duration (in seconds) of the detection window .
The resulting fog-level summary vector is defined as:
() = [(), (), ∆ (), ()] ∈ R4, where each component, respectively, represents the intensity of the anomaly, the diversity of events, the temporal dispersion, and the detection rate calculated by node during the window .
This compact representation is transmitted to the cloud, where it serves as the input for global verification mechanisms and trust-inference algorithms.
By analyzing the set of vectors () reported by all fog nodes, the cloud layer can: • Detect coordinated or distributed attack patterns, • Compare detection behavior across fog regions, • Assess the reliability and consistency of local detections.
These insights are used to compute a replicator coeficient for each fog node, which quantifies its behavioral alignment with the global detection context. This coeficient serves as a key component of the trust-aware fusion mechanism described in the next section.
To dynamically adjust the trust assigned to each fog node, we model their interactions and behavior consistency through an evolutionary game. The game is played at the cloud level among a population of fog nodes ℱ = {1, 2, . . . , }, where each node acts as a player and denotes the total number of fog nodes.
Each fog node is associated with a strategy that reflects the consistency of its metrics reported () compared to those of its neighbors. We consider two main types of strategies: • Honest (H): the node consistently reports indicators that are consistent with both its neighboring nodes and its own past behavior.
• Unreliable (U): the node provides metrics that are inconsistent, noisy, or potentially malicious.
At each time step , the distribution of strategies in the population is represented by the state variables () and (), denoting the proportion of nodes following strategies and , respectively. These proportions satisfy the normalization condition: () + () = 1.
The utility of a fog node playing strategy ∈ {, } is calculated based on the consistency between its reported indicators () and those of its neighbors in the GNN graph. These indicators reflect the node’s local metrics at time (for example, anomaly scores, event frequencies).
Formally, for a node , the utility function () is defined as: () =
∑︁ · sim((), ())
where () denotes the set of neighbors of node , ∈ [
This utility function captures how well the behavior of a node aligns with its local environment. It serves as the basis for the evolutionary game dynamics introduced in the next section, where the nodes adapt their strategies over time according to their relative utilities.
The proportion of each strategy in the population evolves according to replicator dynamics, which models the natural selection process, where strategies with higher-than-average utility become more prevalent over time.
Formally, the evolution of the population share () of the strategy ∈ {, } is given by: ̇() = () (() − ¯( )) where () is the average utility of the nodes that play the strategy , and ¯( ) is the mean utility across the entire population:
¯( ) = () · () + () · ()
In this framework, strategies with utility above the population average grow in proportion, while others decline. This evolution provides a global view of how trustworthy behavior propagates or recedes.
In parallel, each node is also assigned a replicator coeficient (), which reflects its alignment with the prevailing trustworthy behavior. It can be derived from the utility deviation of the node relative to the population, for example:
() = () − ¯( ) This coeficient can be used to adjust trust levels, re-weight connections, or trigger mitigation mechanisms in the intrusion detection framework.
The final stage consists of building a GNN at the cloud level to detect global intrusion by aggregating the indicators () received from all fog nodes. The graph = (, ℰ ) is defined as follows: • = {1, . . . , } is the set of fog nodes. • ℰ ⊆ × contains edges based on communication links or similarity relations. • Each node is associated with a characteristic vector ().
• Each edge (, ) ∈ ℰ is assigned a weight capturing trust or similarity between the two nodes.
To enhance the robustness of the model against unreliable input, the replicator coeficient () ∈ [
˜() = () · () This ensures that nodes with inconsistent or adversarial behavior have less influence in the feature aggregation process. 2. Edge Reweighting: the weights of the edges are also modulated by the product of the replicator coeficients of their endpoints:
˜ = () · () · This penalizes edges involving less trustworthy nodes, reducing their contribution in the messagepassing phase of the GNN.
Final GNN Layer: the GNN is then trained or applied using these reweighted nodes and edges. A generic message-passing layer takes the form:
⎛ ℎ(+1) = ⎝
⎞ ∑︁ ˜ · W()˜()⎠ where is a non-linear activation function, W() the learnable weight matrix at layer , and ˜() the transformed representation of node at layer .
This trust-aware GNN architecture ensures that nodes with poor historical behavior are dynamically down-weighted, while coordinated indicators among trusted fog nodes dominate global inference. As a result, the intrusion detection system remains robust to data drift, observational noise, and adversarial perturbations originating at edge or fog levels. Algorithm 1 Vertical Intrusion Detection with Evolutionary Trust and GNN Inference Input : Raw data streams from edge devices ℰ supervised by each fog node
Output : Global intrusion alerts with dynamic fog trust weighting 1 foreach fog node do 2 Collect and locally process data from supervised edge devices ℰ;
Compute local anomaly indicators () (e.g., anomaly score, detection entropy, temporal divergence;
Transmit () to the cloud layer; 3 foreach fog node do 4 At cloud level, evaluate () across fog nodes;
Compute utility based on: • Consistency with neighboring nodes • Agreement with global detection patterns Update evolutionary trust weight () using replicator dynamics:
( + 1) = () + · () · ( − ¯) where is the adaptation rate and ¯ is the average utility across all fog nodes; 5 Construct GNN = (, ℰ ) where are fog nodes and ℰ encodes proximity or functional relationships; Integrate () as:
• Node weights or message-passing coeficients in GNN layers Run global inference via GNN to identify distributed or coordinated intrusions; return Final alerts with reliability-weighted confidence scores
To assess the efectiveness of our hierarchical and trust-aware intrusion detection framework in an IoT environment, we rely on the UNSW-NB15 dataset. This dataset, developed by the Australian Center for Cyber Security (ACCS), was generated using the IXIA PerfectStorm tool to simulate modern and diverse network trafic, including both normal behavior and a wide range of attacks.
UNSW-NB15 contains a total of 2,540,044 labeled network flow records, each described by 49 features, including basic connection metadata (for example, duration, protocol, port numbers), content-based metrics (e.g., byte and packet counts), and time-related statistics. The attacks are grouped into the following nine categories: Fuzzers, Analysis, Backdoors, DoS, Exploits, Generic, Reconnaissance, Shellcode, and Worms.
Given the constraints of IoT systems, low computational resources, real-time requirements, and partial observability, we selected a representative subset of the dataset, ensuring class balance between benign and malicious trafic. Of the 49 available features, we retained those most suitable for real-time, lightweight anomaly detection at the edge, including the following: • dur – connection duration • spkts, dpkts – packet counts in each direction • sbytes, dbytes – byte volume in each direction • rate – packet transmission rate • sttl, dttl – time-to-live indicators • swin, dwin – TCP window sizes
• ct_state_ttl – state transition patterns
These features are used to compute local anomaly scores using lightweight statistical estimators (e.g., -score normalization, adaptive thresholding), suitable for deployment on constrained IoT edge devices. Vertical Layer Simulation. To reflect the architecture of a realistic IoT deployment, we model a three-tier system composed of Edge, Fog, and Cloud layers: • Edge Layer: a set of low-power IoT nodes (e.g. sensors, smart cameras) collect streaming data in real time and transmit it to their supervising fog node. These edge devices do not perform any local intrusion detection due to resource constraints and lack of global context. • Fog Layer: intermediate fog nodes act as local aggregators, each supervising a group of 10–20 edge nodes. They receive raw data, perform local anomaly detection (for example, temporal divergence based on entropy) and transmit anomaly indicators () to the cloud. • Cloud Layer: the global coordination layer is implemented using a spatio-temporal Graph Neural Network (GNN), where each fog node is a vertex. The edges between the fog nodes are dynamically weighted using a replicator equation from evolutionary game theory, based on the consistency and precision of the reports received.
To simulate adversarial environments, we deliberately degrade the trustworthiness of a subset of fog nodes by injecting uncertainty and noise into their anomaly indicators. Specifically, we select up to 20% fog nodes to behave adversarially, either through random perturbations, delayed reporting, or inconsistent signaling—mimicking scenarios such as node compromise, software malfunction, or targeted misinformation. The GNN-based model refines threat detection by leveraging spatio-temporal correlations in the graph topology and dynamically adjusting trust weights through evolutionary feedback, thus mitigating the influence of unreliable nodes over time.
This layered simulation allows us to evaluate the localized detection performance at the fog level, where partial anomaly fusion is performed, as well as the global correlation capabilities at the cloud level using GNN inference. In particular, we compare a standard hierarchical IDS with our proposed evolutionary trust-based IDS (eIDS) in terms of detection accuracy, false positive rate, and robustness under noisy or adversarial conditions.
To thoroughly assess the efectiveness of our proposed evolutionary trust-based IDS (eIDS), we compare it against several baseline architectures, each representing a diferent class of intrusion detection strategies commonly adopted in IoT environments: (1) Flat Centralized IDS (Central-IDS). Traditional architecture where all edge devices forward raw or preprocessed flow data directly to a centralized cloud-based detection system. This IDS uses a conventional supervised model trained on global features, without hierarchy or distributed intelligence. (2) Hierarchical IDS without Trust Mechanism (H-IDS). A three-tier architecture similar to ours (Edge–Fog–Cloud), where fog nodes collect flow data from edge devices and perform local anomaly detection independently. The cloud layer performs global correlation based on static topological connections between the fog nodes. This baseline does not incorporate any trust-aware fusion or adaptive graph structure; the cloud layer operates with fixed edge weights. (3) Hierarchical IDS with Static Trust Weights (S-eIDS). An enhanced hierarchical IDS where fog-level detection is enhanced with pre-assigned trust values between fog nodes. These static trust weights are based on historical metrics such as uptime or past detection reliability. However, the trust graph remains fixed over time, without any dynamic adaptation or feedback mechanism. (4) Proposed Model – Evolutionary Trust-based IDS (eIDS). Our full system, which includes: (i) unsupervised anomaly detection and signal fusion at the fog layer, (ii) global spatio-temporal correlation through a GNN at the cloud level, and (iii) dynamic adjustment of trust weights between fog nodes using evolutionary replicator dynamics, allowing the system to penalize unreliable nodes and reinforce trustworthy ones over time.
Evaluation Metrics. We evaluate all models using the following performance indicators: • Area Under the ROC Curve (AUC): measures the general discriminative ability of the model across thresholds. • True Positive Rate (TPR): proportion of correctly detected malicious flows among all malicious ones. • False Positive Rate (FPR): proportion of benign flows incorrectly identified as malicious. • Trust Stability Index (TSI): captures the consistency of the evolution of the trust coeficient over training epochs.
Each experiment is repeated over 10 randomized train-test splits to ensure statistical significance. For all hierarchical models, we maintain the same number of edge and fog nodes and inject synthetic faults into a subset of fog nodes (up to 20%) to simulate adversarial behavior.
Implementation Details. All models are implemented in Python using PyTorch and PyTorchGeometric for the GNN modules. The replicator dynamics are implemented as a feedback loop between epochs, updating the edge weights in the graph adjacency matrix. Training is carried out for 50 epochs using the Adam optimizer, with early stopping based on AUC validation.
We report the detection performance of all models on the UNSW-NB15 dataset in terms of AUC, TPR, and FPR.
Figure 3 shows the ROC curves averaged over more than 10 runs. Our proposed model, Evolutionary Trust-based IDS (eIDS), consistently outperforms all baselines, achieving an average AUC of 0.85, with a higher true positive rate and a lower false positive rate across all thresholds. In contrast, the Flat Central-IDS model performs significantly worse, with an AUC of only 0.67, highlighting the limitations of centralized detection in dynamic and distributed IoT environments. The Hierarchical IDS without trust and the Static Trust-based IDS obtain intermediate results, with AUCs of 0.73 and 0.78, respectively. These results demonstrate the advantage of integrating an adaptive trust mechanism into the detection process, allowing the system to better handle adversarial or noisy conditions.
Figure 4 compares false positive rates (FPR) in diferent IDS architectures using a boxplot over multiple runs. The Flat Central-IDS shows the highest FPR, illustrating the limitations of centralized decision-making in dynamic environments. Both Hierarchical IDS (no trust) and Static Trust-based IDS demonstrate moderate variability in FPR, reflecting their limited adaptability when faced with compromised fog nodes. In contrast, the evolution trust-based IDS (eIDS) achieves the lowest and most stable FPR, thanks to its ability to dynamically reduce the influence of unreliable nodes through evolving trust scores in the GNN-based correlation mechanism.
Figures 5 and 6 jointly illustrate the evolution of replicator dynamics and the resulting trust coeficients for five Fog nodes over time. A strong positive correlation is observed between replicator values and trust levels, as expected from the softmax-based trust calculation mechanism.
In Figure 5, Fog Nodes 1 and 2 maintain high and stable replicator values throughout the 50 time steps, indicating consistent cooperative behavior. In contrast, Nodes 3, 4, and 5 exhibit a clear and progressive decline in their replicator values, with Node 5 eventually dropping to zero. This decline reflects a sustained deviation from the expected cooperative behavior, which can be attributed to malicious actions or persistent ineficiency.
Figure 6 shows how the trust coeficients evolve accordingly. Nodes 1 and 2 gain progressively higher trust, with their coeficients increasing from approximately 0.20 to above 0.30. However, the trust values for Nodes 3, 4, and 5 gradually decrease below the initial baseline, approaching 0.10 for Node 5. This reflects the direct impact of their decreasing replicator values on the trust computation process.
Overall, these results validate the efectiveness of using replicator dynamics as an input to the trust model: cooperative nodes are rewarded with increasing trust, while uncooperative or malicious behavior is penalized with decreasing trust, enabling adaptive and reliable trust management in distributed Fog environments.
This paper introduced a vertical intrusion detection system (V-IDS) for hierarchical IoT architectures. Combining GNN-based alert fusion with an evolutionary game-theoretic trust mechanism, the model enables structural and temporal reasoning over a two-layer Fog–Cloud setup and improves resilience by dynamically adjusting node influence based on trust. The system mitigates the impact of unreliable or malicious nodes by embedding trust evolution into the GNN via adaptive edge weights, guided by local performance and neighborhood feedback. To ensure tractability, we focus on a two-layer detection model. Extending the architecture to include a third Edge layer is feasible but adds computational complexity, and will be addressed in future work.
The next steps include formal analysis of evolutionary dynamics, dense graph scalability studies, integration with federated learning for privacy, and a broader empirical evaluation of real-world data sets. This research contributes to adaptive, robust, and intelligent IDSs for secure IoT infrastructures.
During the preparation of this work, the authors used ChatGPT 5.1 and Writefull for grammar and spelling checks, as well as for paraphrasing and rewording certain sentences. After using these tools, the authors carefully reviewed, validated and edited all generated content. The authors assume full responsibility for the accuracy and integrity of the final manuscript.