Federated Graph Neural Network–Deep Reinforcement Learning for Resilient and Trust-Aware Resource Allocation in Zero Trust SDN Networks

Featured Application

6G multi-domain network orchestration.

Abstract

Existing solutions for resource allocation in Zero Trust (ZT) SDN networks treat security, resilience, and efficiency separately; centralised approaches violate data privacy; deep reinforcement learning (DRL) lacks trust dynamics; and federated learning (FL) has not incorporated graph neural networks (GNNs) or failure resilience. These limitations motivate a federated GNN-DRL framework that preserves data locality while jointly optimising trust, resilience, and performance. Each domain trains a local GNN-DRL agent with a GNN encoder for topology awareness and a hybrid DRL module (Deep Q-Network for discrete failover actions and Soft Actor-Critic for continuous bandwidth tuning) under a stochastic trust evolution modelled by stochastic differential equations (SDEs) with a reflection mechanism to ensure well-posedness. Three pseudo-code algorithms detail client-side training (Algorithm 1), server-side q-fair aggregation (Algorithm 2), and local gradient updates (Algorithm 3). Extensive simulations on a 100-node topology divided into five domains demonstrate that: (i) under low-to-moderate failures (≤20%), trust violations remain below 1.8%, and even under severe failures (40%), violations stay at 4.2% (within the 5% ZT boundary); (ii) recovery time is reduced by 53%; (iii) throughput under failures improves by 32%; (iv) compromise resistance reaches seven nodes (vs. three centralised); (v) attack surface shrinks to four nodes (vs. 98 baseline); and (vi) lateral movement containment attains 98%. The federated framework approaches centralised performance while preserving data locality, offering a practical and secure solution for multi-domain ZT, SDN networks.

1. Introduction

The proliferation of cloud-native applications, Internet of Things deployments, and sixth-generation (6G) services demands network infrastructures that are simultaneously programmable, secure, and resilient. Software-Defined Networking (SDN) addresses programmability by decoupling the control plane from the data plane, enabling centralised network intelligence and dynamic reconfiguration [1]. While [1] enables network programmability, it introduces centralised attack surfaces such as controller saturation and flow table exhaustion. Simultaneously, the ZT Architecture (ZTA) paradigm has emerged as the de facto standard for securing distributed, multi-tenant environments, operating on the principle of “never trust, always verify” [2]. Ref. [2] establishes ZTA principles but does not address dynamic resource allocation or resilience under failures. ZTA requires continuous authentication, authorisation, and validation for every access request, regardless of origin, effectively eliminating the concept of trusted internal networks.

The convergence of SDN and ZTA offers a powerful synergy: SDN programmability provides the technical substrate for implementing granular, dynamic ZT policies at the flow level, while ZTA supplies the security framework that ensures continuous verification across programmable environments [3]. Ref. [3] analyses threat vectors in SDN but lacks a unified framework that jointly optimises trust, resilience, and performance. However, this integration introduces a fundamental resource allocation challenge that existing solutions do not address. Resource allocation must simultaneously satisfy dynamic trust constraints (which evolve stochastically based on observed behaviour and vulnerability scores), survive network failures (link outages, node compromises, controller crashes), and optimise multiple performance objectives (throughput, latency, energy efficiency). Traditional approaches treat security, resilience, and resource efficiency as orthogonal concerns, leading to suboptimal trade-offs and exploitable gaps between protection mechanisms [4]. Ref. [4] reviews ZTA challenges across domains but does not incorporate learning-based adaptation.

Graph neural networks (GNNs) have recently shown remarkable ability to learn representations of graph-structured data, capturing both local node attributes and global topological dependencies [5]. Ref. [5] surveys GNNs for resilience prediction but ignores trust constraints and privacy. In the context of network resilience, GNNs can model failure propagation patterns and predict which components are vulnerable before they fail. Deep reinforcement learning (DRL) has been successfully applied to dynamic resource allocation in SDN, enabling agents to learn optimal policies through interaction with the environment [6]. Ref. [6] applies DRL to MEC resource allocation but assumes centralised control and trusted environments, which are invalid in ZT settings. However, existing DRL solutions do not incorporate trust dynamics or guarantee feasibility in the presence of failures and most assume a centralised controller with access to all network data.

In many realistic ZT SDN deployments, especially across multiple administrative domains (different cloud providers, edge regions, or IoT tenants), sharing raw network state and trust scores may violate privacy regulations or business policies. Federated learning (FL) offers a natural extension: each domain trains a local model on its own private data, and only model updates are sent to a central server for aggregation [7]. This preserves data locality while still allowing global improvement. This paper presents a federated GNN-DRL framework for resilient, trust-aware resource allocation in ZT SDN networks. The main contributions are fourfold. First, we formulate the problem as a constrained Markov decision process with stochastic trust evolution, including model graphs of trust trajectories and failure cascades. Second, we design a local GNN-DRL agent that captures topological dependencies and optimises discrete and continuous actions, providing pseudo-code for training. Third, we propose a FL architecture with client-side and server-side algorithms, including a fairness-aware aggregation rule. Fourth, we integrate security robustness analysis (compromise resistance, attack surface, lateral movement containment) into the evaluation and present several performance evaluation results showing that the federated framework approaches centralised performance while preserving privacy.

The remainder of the paper is organised as follows: Section 2 provides a comprehensive review of related work, including an analysis of security robustness. Section 3 presents the system model and problem formulation, including model graphs of trust evolution and failure propagation. Section 4 describes the proposed federated GNN-DRL framework, including three pseudo-code algorithms. Section 5 evaluates the framework through simulations, presenting performance and security plots. Section 6 concludes the paper.

2. Related Work

The intersection of ZT security, SDN resource allocation, and network resilience has been explored across several distinct but complementary research streams. In this section, we systematically categorise existing approaches into five classes: traditional optimisation and heuristic methods, supervised learning for network modelling, deep reinforcement learning for resource allocation, FL for network optimisation, and security robustness analysis in ZT networks.

2.1. Traditional Optimisation and Heuristic Methods

Classical resource allocation in SDN has relied on mathematical programming and heuristic algorithms. Mixed integer linear programming (MILP) formulations have been used to optimise flow routing and bandwidth allocation, but they become computationally intractable for large topologies and fail to adapt to dynamic trust or failure conditions [8]. Heuristic approaches, such as OSPF with precomputed backup paths, offer fast failover but lack awareness of security constraints or load variations. A comprehensive survey of SDN resilience [9] highlights that static methods cannot cope with the stochastic nature of cyberattacks and cascading failures. The ZFort framework [1] introduced stochastic differential equations for trust evaluation but relied on static heuristics for resource allocation, without learning or adaptation. These traditional methods treat security, resilience, and performance as separate objectives, leading to suboptimal trade-offs.

2.2. Supervised and Unsupervised Learning for Network Modelling

Graph neural networks (GNNs) have emerged as a powerful tool for learning representations of graph-structured data, capturing both local node attributes and global topological dependencies [5]. In networking, GNNs have been applied to predict link reliability, estimate traffic matrices, and identify vulnerable components before they fail [5,10]. Specific architectures, such as RDG-TE, have demonstrated that link-reliability-aware DRL-GNN models can improve traffic engineering under failures [10]. However, these works focus on resilience prediction and do not incorporate trust constraints, security metrics, or FL.

Beyond networking, representative deep learning methods from other domains highlight the common challenges of complex structure modelling, feature interaction, and robustness. For instance, machine-vision-driven physics-informed neural networks have been successfully applied to pantograph–catenary system state detection [11], demonstrating how hybrid physical data models can capture intricate spatial–temporal dynamics. Similarly, spatial channel collaborative multi-scale graph interaction deep transfer learning has been proposed for unsupervised rotating machinery fault diagnosis [12], illustrating the importance of multi-scale feature aggregation and cross-domain generalisation. These works inspire our use of Graph Attention Networks (GATs) [13] to capture neighbour importance and multi-scale topological features for failure propagation modelling in SDN.

2.3. Deep Reinforcement Learning for Resource Allocation

Deep reinforcement learning (DRL) has advanced significantly in recent years. Multi-objective reinforcement learning for automated resilient cyber defence has been explored to balance competing security objectives [14]. Foundational algorithms include Deep Q-Networks (DQNs) [15], which handle discrete action spaces, and Proximal Policy Optimization (PPO) [16], an on-policy method for continuous control. More recently, off-policy algorithms such as Soft Actor-Critic (SAC) have been adopted for their sample efficiency and stability [17]. In the context of SDN and 6G networks, multi-objective DRL approaches with dynamic weight adaptation have been shown to balance throughput, delay, and energy efficiency [6]. Hierarchical multi-agent RL frameworks have been proposed for network slicing, achieving sub-millisecond latency for URLLC traffic. However, these works assume a trusted centralised controller with full state visibility, which conflicts with ZT principles. Moreover, none of these DRL solutions incorporate dynamic trust evolution or guarantee feasibility under failures.

2.4. FL for Network Optimisation

FL enables collaborative model training without sharing raw data, preserving data locality across administrative domains. A hybrid FL-DRL approach combined with convex optimisation was developed for Age-of-Information (AoI) minimisation in heterogeneous MEC networks [18]. The canonical FedAvg algorithm [19] aggregates local model updates weighted by dataset sizes. Extensions such as q-fair FL [20] introduce fairness-aware aggregation to prevent domains with larger datasets from dominating the global model. A fair FL framework for collaborative network traffic prediction and resource allocation was proposed in [7], but that work did not incorporate resilience, GNNs, or trust constraints. More recently, a hybrid FL-DRL approach combined with convex optimisation was developed for Age-of-Information (AoI) minimisation in heterogeneous MEC networks [15]. While [18] shares our motivation of combining FL and DRL, it does not address ZT security, network failures, or graph-based topology modelling. The gap remains: no existing FL framework jointly optimises trust-aware resource allocation, network resilience, and performance in multi-domain SDN environments.

2.5. Security Robustness in ZT Networks

Security robustness in ZT networks has been studied using Markov models and graph theory. The expected number of nodes that an adversary must compromise to access a critical resource has been shown to be related to the eigenvalues of the trust graph Laplacian [21]. Attack surface reduction through micro-segmentation has been quantified, with lateral movement containment reaching 93% under strict policies [22]. The NIST Special Publication 800-207 [23] formally defines ZT Architecture principles, including continuous verification, micro-segmentation, and least-privilege access, but does not provide dynamic resource allocation algorithms. Existing security analyses have not been integrated into a learning-based resource allocation framework that simultaneously optimises performance and resilience.

2.6. Research Gap Summary

The literature review reveals a clear gap: no existing framework jointly optimises resilience, trust-aware resource allocation, and performance in ZT SDN networks while preserving data privacy across domains and providing quantitative security robustness guarantees. GNNs have been used for resilience, DRL for resource allocation, FL for privacy, and Markov models for security analysis, but they have not been integrated into a single federated framework. This paper fills that gap by proposing a federated GNN-DRL framework with q-fair aggregation, stochastic trust modelling, and comprehensive security metrics.

3. System Model

In this section, we consider a multi-domain SDN network partitioned into $K$ domains, each managed by a local SDN controller. Domains do not share raw network state; they only exchange model updates during federated training. Within each domain $k$, the local network is represented as a directed graph $G_k=(V_k,E_k)$, where $V_k$ is the set of nodes (switches, controllers, endpoints) and $E_k$ is the set of directed links. Each node $v\in V_k$ has processing capacity $C_v$ (packets per second) and memory $M_v$ (bytes). Each link $e\in E_k$ has bandwidth capacity $B_e$ (bits per second) and propagation delay $d_e$ (milliseconds). The domain carries a set of flows $F_k$. Each flow $f\in F_k$ is characterised by a source node $s_f$, a destination node $d_f$, a bandwidth demand $b_f$, a maximum tolerable latency ${\mathcal{l}}_f$, a security class $c_f\in \{1,2,3\}$ (critical, data, background), and a minimum trust requirement ${\theta }_f\in [0,1]$.

To facilitate readability, Table 1 summarises the key symbols used throughout this section.

Table 1. Nomenclature of key system variables.

Symbol	Meaning	Dimension	Value/Range
$T_v(t)$	Trust score of node $v$ at time $t$	Dimensionless	$\left[0,1\right]$
${\mu }_v$	Baseline trust derived from CVSS score	Dimensionless	$\left[0.7,0.99\right]$
${\kappa }_v$	Mean reversion rate of trust	$s^{-1}$	$0.1$ (fixed)
${\sigma }_v$	Volatility (diffusion) of trust	$s^{-1/2}$	$0.05$ (fixed)
$B_e$	Bandwidth capacity of link $e$	bps	${10}^{10}$
$d_e$	Propagation delay of link $e$	ms	$1$–$20$
${\theta }_f$	Minimum trust requirement for flow $f$	Dimensionless	0.6, 0.8, 0.95
${\mathcal{l}}_f$	Maximum tolerable latency for flow $f$	ms	$5,20,\mathrm{\infty }$
${\rho }_f(t)$	Indicator of whether flow $f$ is active at time $t$	Dimensionless	$\left\{0,1\right\}$
$\mathcal{R}$	Resilience metric (fraction of delivered traffic)	Dimensionless	$\left[0,1\right]$
$y_{fe}(t)$	Bandwidth allocated to flow $f$ on link $e$ at time $t$	bps	$\ge$0
${\alpha }_{vu}^{\left(l\right)}$	GAT attention coefficient from node $u$ to $v$ at layer $l$	Dimensionless	$\left[0,1\right]$

3.1. Trust Evolution Model

Trust is dynamic and stochastic. For each node $v$, let $T_v(t)\in [0,1]$ be its trust score at time $t$. Figure 1 illustrates an example trust trajectory for a node with baseline trust ${\mu }_v=0.9$, mean reversion rate $\kappa =0.1$, and volatility $\sigma =0.05$. The plot shows mean reversion and random Wiener fluctuations.

Figure 1. Trust evolution trajectory for a node with $\mu =0.9$, $\kappa =0.1$, $\sigma =0.05$. Note that in Figure 1, the blue line shows the stochastic trust score; the dashed red line indicates the baseline trust.

The evolution of trust is modelled by a stochastic differential equation (SDE) that captures three key effects: mean reversion to a CVSS-derived baseline, random fluctuations due to behavioural uncertainty, and trust propagation from neighbours:

$$\mathrm{d}{\mathrm{T}}_{\mathrm{v}}(\mathrm{t})={\mathsf{\kappa }}_{\mathrm{v}}({\mathsf{\mu }}_{\mathrm{v}}-{\mathrm{T}}_{\mathrm{v}}(\mathrm{t}))\mathrm{d}\mathrm{t}+{\mathsf{\sigma }}_{\mathrm{v}}\mathrm{d}{\mathrm{W}}_{\mathrm{v}}(\mathrm{t})+\sum _{\mathrm{u}\in \mathcal{N}(\mathrm{v})}{\mathsf{\beta }}_{\mathrm{v}\mathrm{u}}({\mathrm{T}}_{\mathrm{u}}(\mathrm{t})-{\mathrm{T}}_{\mathrm{v}}(\mathrm{t}))\mathrm{d}\mathrm{t},$$

(1)

where ${\kappa }_v>0$ is the mean reversion rate, ${\mu }_v=1-{\mathrm{CVSS}}_v/10$ is the baseline trust derived from the Common Vulnerability Scoring System score of node $v$, ${\sigma }_v$ is the volatility parameter, $d{W}_v(t)$ is a Wiener process increment, $\mathcal{N}(v)$ is the set of neighbours, and ${\beta }_{vu}\ge 0$ are trust propagation weights satisfying ${\sum }_u{\beta }_{vu}\le 1$.

Well-posedness of the SDETo guarantee that the trust score $T_v(t)$ remains within the meaningful interval $\left[0,1\right]$ despite the Wiener noise, we apply a reflection/projection mechanism at each discrete time step. Let $\mathsf{\Delta }{T}_v(t)$ denote the right-hand side of (1) multiplied by the discretisation step $\mathsf{\Delta }t$. The updated trust is then:

$$T_v(t+\mathsf{\Delta }t)=\mathrm{m}\mathrm{i}\mathrm{n}\left(1,\mathrm{m}\mathrm{a}\mathrm{x}\left(0,T_v(t)+\mathsf{\Delta }{T}_v(t)\right)\right).$$

(2)

This ensures numerical stability and preserves the probabilistic interpretation of trust as a bounded score.

Figure 2 summarily illustrates the trust propagation graph. Nodes with high trust influence neighbours through the coupling coefficients ${\beta }_{vu}$, shown as directed edges with varying thickness.

Figure 2. Trust propagation graph illustrating directed trust influence coefficients ${\beta }_{vu}$ between nodes.

For a given flow $f$ and a candidate path $p$, the path trust score is defined as the minimum trust along the path:

$$T_p(t)=\underset{v\in p}{\mathrm{m}\mathrm{i}\mathrm{n} }{T}_v(t).$$

(3)

The flow must use a path $p_f$ such that $T_{p_f}(t)\ge {\theta }_f$ at all times, ensuring that no single low-trust node compromises the entire path.

3.2. GNN Attention and Failure Modelling

Illustrated by Figure 3 is the attention mechanism of the Graph Attention Network: different shades of edges represent learned attention coefficients ${\alpha }_{vu}$, highlighting which neighbours are the most influential for failure prediction. Darker edges indicate higher attention.

Figure 3. GNN attention map illustrating learned attention coefficients ${\alpha }_{vu}$ between a central node and its neighbours. Note that in the same Figure edge thickness and colour intensity are proportional to the attention value (higher attention = thicker, darker edge). Numerical labels indicate exact attention coefficients.

Failures are modelled as random events that remove nodes or links. Let $\mathcal{F}(t)\subset V_k\cup E_k$ be the set of failed components in domain $k$ at time $t$. The post-failure graph is $G_k^{\prime }(t)=G_k\setminus \mathcal{F}(t)$. Link failures follow a Bernoulli process with probability $p_e$ per time step, and node failures follow a Poisson process with rate ${\lambda }_v$. Cascade failures occur when a failed node causes overload on its neighbours; a node $v$ fails at time $t+1$ if its load $L_v(t)$ exceeds its capacity $C_v$ after redistribution.

Figure 4 presents a cascade failure simulation: initially, one node fails (load exceeds capacity); load is redistributed to neighbours; a second node fails after 2 ms; and the cascade propagates across the topology. The graph shows the number of failed nodes over time.

Figure 4. Cascade failure simulation: initial node failure triggers load redistribution, causing progressive failures.

3.3. Resilience and Resource Allocation

Let ${\rho }_f(t)$ be an indicator that flow $f$ is active at time $t$:

$${\rho }_f\left(t\right)=1\mathrm{if}\mathrm{there}\mathrm{exists}\mathrm{a}\mathrm{path}{p}_f\left(t\right)\mathrm{in}{G}_k^{\prime }\left(t\right)\mathrm{satisfying}{T}_{p_f\left(t\right)}\left(t\right)\ge {\theta }_f\mathrm{and}{\tau }_f\left(p_f\left(t\right)\right)\le {\mathcal{l}}_f,$$

and ${\rho }_f(t)=0$ otherwise. The overall throughput in domain $k$ is ${\sum }_{f\in F_k}{b}_f{\rho }_f(t)$. The resilience metric over a time horizon $\left[0,T\right]$ is the average fraction of traffic delivered:

$$\mathcal{R}={\displaystyle \frac{1}{T}}{\int }_0^T{\displaystyle \frac{{\displaystyle {\sum }_{k=1}^K}{\sum }_{f\in F_k}{b}_f{\rho }_f(t)}{{\displaystyle {\sum }_{k=1}^K}{\sum }_{f\in F_k}{b}_f}}dt.$$

(4)

Interpretation of the resilience metric. The resilience metric $\mathcal{R}$ quantifies the time-averaged fraction of the total offered traffic that successfully reaches its destination, accounting for both link/node failures and trust violations that invalidate paths. A value of 1 indicates perfect delivery under all conditions; lower values reflect performance degradation during adverse events. This metric captures the network’s ability to maintain service continuity despite failures and trust degradation.

The resource allocation decisions in domain $k$ are represented by variables $y_{fe}(t)$ denoting the bandwidth allocated to flow $f$ on link $e$ at time $t$. Link utilisation is:

$$u_e(t)={\displaystyle \frac{{\sum }_f{y}_{fe}(t)}{B_e}}.$$

(5)

The cost of congestion is ${\mathrm{cost}}_e(u_e)=u_e^2$. The optimisation problem for each domain seeks to maximise a weighted combination of throughput, trust compliance, and resilience:

$$\mathrm{m}\mathrm{a}\mathrm{x} \mathbb{E}\left[{\int }_0^T\left(w_1\sum _{f\in F_k}{b}_f{\rho }_f(t)-w_2\sum _{f\in F_k}{\mathbf{1}}_{\left\{T_{p_f(t)}(t)<{\theta }_f\right\}}-w_3\sum _{e\in E_k}{u}_e(t{)}^2\right)dt\right],$$

(6)

subject to capacity constraints ${\sum }_f{y}_{fe}(t)\le B_e$ and flow conservation at each node.

3.4. Interpretation of the Optimisation Objective

Equation (7) defines a constrained Markov decision process (CMDP). The first term maximises throughput, rewarding successful delivery of traffic. The second term penalises trust violations via the indicator function, ensuring that paths with insufficient trust are discouraged. The third term penalises congestion via quadratic link utilisation, promoting load balancing and preventing bottlenecks. The weights $w_1,w_2,w_3\ge 0$ balance these competing objectives. Constraints ensure that the total allocated bandwidth on each link does not exceed its capacity and that flow conservation (Kirchhoff’s laws) holds at every node. Because domains cannot share raw data, we solve this problem using the FL approach described in Section 4.

4. Federated GNN-DRL Framework

The proposed framework consists of a central server and multiple client domains. Figure 5 illustrates the overall architecture: each client runs a local GNN-DRL agent on its own private network state; clients periodically send model updates to the server; the server aggregates updates using a q-fair aggregation rule and broadcasts the updated global model back to clients. The framework is designed to preserve data locality while enabling collaborative learning across domains.

Figure 5. Proposed architecture of the federated GNN-DRL framework. The diagram shows the complete workflow from input to aggregated global model. Solid arrows indicate forward data flow (state encoding, action selection, environment interaction, and reward feedback). Dashed arrows indicate model update and feedback paths (local model upload, global model broadcast, and GNN backpropagation). Dotted arrows indicate the replay buffer sampling process.

As can be seen from Figure 5, the architecture comprises the following: (i) inputs to the GNN encoder (node features ${\mathbf{x}}_v$, edge features ${\mathbf{e}}_{uv}$, adjacency matrix); (ii) the GNN encoder outputting graph-level embedding ${\mathbf{h}}_{G_k}$; (iii) branching to DQN for discrete actions (failover, rerouting, backup activation) and SAC for continuous actions (bandwidth allocation, rate limiting); (iv) environment interaction producing reward $r_t$ and next state; (v) replay buffer storing transitions $\left(h_G,a_d,a_c,r,h_{G_{\mathrm{next}}}\right)$; (vi) local model update $\mathsf{\Delta }{\theta }_k$ uploaded to the server; and (vii) server-side q-fair aggregation producing global model ${\theta }_{\mathrm{global}}$ broadcast back to clients.

4.1. Local GNN-DRL Agent

Each client $k$ maintains a local GNN encoder and a hybrid DRL module. The GNN encoder transforms the local network state into compact embeddings that capture both node attributes and topological structure. At each time step, the local state is represented as a graph with node features ${\mathbf{x}}_v(t)$ including load, queue length, trust score, failure status, and degree centrality, and edge features ${\mathbf{e}}_{uv}(t)$ including utilisation, delay, and reliability.

A Graph Attention Network (GAT) [13,14] is used to assign different importance to neighbours. The GAT layer computes new node representations as:

$${\mathbf{h}}_v^{\left(l+1\right)}=\sigma \left(\sum _{u\in \mathcal{N}(v)\cup \left\{v\right\}}{\alpha }_{vu}^{\left(l\right)}{\mathbf{W}}^{\left(l\right)}{\mathbf{h}}_u^{\left(l\right)}\right),$$

(7)

with attention coefficients ${\alpha }_{vu}^{\left(l\right)}$ computed by a feedforward layer that learns the relative importance of neighbour $u$ to node $v$. After $L$ layers, a global graph embedding for the domain is obtained by mean pooling:

$${\mathbf{h}}_{G_k}={\displaystyle \frac{1}{\mid V_k\mid }}{\sum }_{v\in V_k}{\mathbf{h}}_v^{\left(L\right)}.$$

(8)

The DRL agent has a hybrid architecture designed to handle both discrete and continuous actions simultaneously. Discrete actions (controller failover, rerouting, activating backup paths) are handled by a Deep Q-Network (DQN) [15], which selects among a finite set of high-level control decisions. Continuous actions (bandwidth allocation, rate limiting) are handled by Soft Actor-Critic (SAC), an off-policy algorithm that naturally supports experience replay and provides stable, sample-efficient learning for continuous control [17]. We choose SAC over on-policy alternatives such as PPO because SAC’s off-policy nature is compatible with the replay buffer used in our federated setting, whereas PPO would require discarding the replay buffer or violating its theoretical foundations.

The reward function at each step for client $k$ is designed to balance throughput maximisation, trust compliance, and congestion minimisation:

$$r_t={\eta }_1{\displaystyle \frac{{\sum }_{f\in F_k}{b}_f{\rho }_f(t)}{{\sum }_{f\in F_k}{b}_f}}-{\eta }_2{\displaystyle \frac{1}{\mid F_k\mid }}\sum _{f\in F_k}{1}_{\left\{T_{p_f(t)}(t)<{\theta }_f\right\}}-{\eta }_3{\displaystyle \frac{1}{\mid E_k\mid }}\sum _{e\in E_k}{u}_e(t{)}^2.$$

(9)

The first term rewards high throughput; the second term penalises trust violations; and the third term discourages link congestion. The weights ${\eta }_1,{\eta }_2,{\eta }_3$ balance these competing objectives. The GNN and DRL components are trained jointly using experience replay. Algorithm 1 presents the client-side training procedure for one federated round.

Algorithm 1: Federated GNN-DRL client training (domain $k$)

Input: Local network environment, number of local episodes $M_{\mathrm{local}}$, received global model ${\theta }_{\mathrm{global}}$ (GNN, DQN, SAC parameters) Output: Local model update $\mathsf{\Delta }{\theta }_k$ 1.   Initialise local model ${\theta }_k\leftarrow {\theta }_{\mathrm{global}}$ 2.   Initialise local replay buffer $B_k=\mathrm{\varnothing }$ 3.   for local_episode = 1 to $M_{\mathrm{local}}$ do 4.   Reset local environment, observe initial state $s_0$ 5.   for $t=1$ to $T_{\mathrm{m}\mathrm{a}\mathrm{x}}$ do 6.   ${\mathbf{h}}_G={\mathrm{GNN}}_{\phi }(s_t)$ // Encode state with GNN 7.   $a_d\leftarrow \epsilon \text{-greedy}\left({\mathrm{DQN}}_{{\theta }_{\mathrm{DQN}}}(\cdot \mid {\mathbf{h}}_G)\right)$ // Select discrete action 8.   $a_c\sim {\pi }_{{\theta }_{\mathrm{SAC}}}(\cdot \mid {\mathbf{h}}_G)$ // Sample continuous action from SAC Actor 9.   Execute combined action $\left(a_d,a_c\right)$, obtain reward $r_t$ and next state $s_{t+1}$ 10. Store transition $\left(h_G,a_d,a_c,r_t,h_{G_{\mathrm{next}}}\right)$ in $B_k$ 11. Sample mini-batch from $B_k$ 12. Update SAC Critic, Actor, and temperature $\alpha$ using SAC losses 13. Update DQN: minimise $L_{\mathrm{DQN}}={\left(r+\gamma {\mathrm{m}\mathrm{a}\mathrm{x}}_{a^{\prime }}Q(s^{\prime },a^{\prime })-Q(s,a)\right)}^2$ 14. Update GNN $\phi$ by backpropagating $L_{\mathrm{total}}=L_{\mathrm{SAC}}+{\lambda }_1{L}_{\mathrm{DQN}}+{\lambda }_2\parallel {\nabla }_{\phi }{\parallel }_2^2$ 15. end for 16. end for 17. Compute model update $\mathsf{\Delta }{\theta }_k={\theta }_k-{\theta }_{\mathrm{global}}$ 18. Send $\mathsf{\Delta }{\theta }_k$ to server

Hybrid Action Bellman Formulation

The joint hybrid action space poses a non-trivial Bellman optimality problem. Let the hybrid action be $a=(a_d,a_c)\in {\mathcal{A}}_d\times {\mathcal{A}}_c$, where ${\mathcal{A}}_d$ is a finite set of discrete failover actions and ${\mathcal{A}}_c\subset {\mathbb{R}}^m$ is a continuous bandwidth allocation space. The action-value function is:

$$Q(s,a_d,a_c)=\mathbb{E}\left[{\displaystyle \sum _{t=0}^{\mathrm{\infty }}}{\gamma }^t{r}_t|s_0=s,a_d(0)=a_d,a_c(0)=a_c\right].$$

(10)

The joint Bellman optimality equation is:

$$Q^{*}(s,a_d,a_c)={\mathbb{E}}_{s^{\prime }\sim P(\cdot \mid s,a_d,a_c)}\left[r(s,a_d,a_c)+\gamma \underset{a_d^{\prime }\in {\mathcal{A}}_d}{\mathrm{m}\mathrm{a}\mathrm{x}}{\mathbb{E}}_{a_c^{\prime }\sim \pi (\cdot \mid s^{\prime })}{Q}^{*}(s^{\prime },a_d^{\prime },a_c^{\prime })\right].$$

(11)

The expectation over $a_c^{\prime }$ is taken with respect to the SAC policy $\pi$, while the maximisation over $a_d^{\prime }$ is performed by the DQN. Critically, the continuous action $a_c^{\prime }$ is conditioned on the discrete action $a_d^{\prime }$: the bandwidth allocation policy depends on the chosen failover action. This coupling is captured by our joint reward function (Equation (10)) and the sequential update procedure in Algorithm 1, where the discrete action is selected first (via DQN), followed by the continuous action conditioned on it (via SAC). This sequential conditioning is a practical approximation to the full joint Bellman optimality, chosen to balance tractability with performance.

4.2. Server-Side Aggregation

The server collects updates from all participating clients and aggregates them to form a new global model. To ensure fairness across domains with different data sizes and trust levels, we use a weighted aggregation based on the number of flows in each domain, optionally with a q-fair correction [20]. The q-fair mechanism upweights domains with higher local loss, preventing the global model from being dominated by domains with larger datasets. The server then broadcasts the updated global model back to clients. Algorithm 2 details the server-side procedure.

Algorithm 2: Federated GNN-DRL server aggregation

Input: Number of clients $K$, federated rounds $R$, aggregation rule (FedAvg with q-fairness) Output: Global model ${\theta }_{\mathrm{global}}$ 1.   Initialise global model ${\theta }_{\mathrm{global}}$ randomly 2.   for round $r=1$ to $R$ do 3.   Broadcast ${\theta }_{\mathrm{global}}$ to all clients 4.   for each client $k=1$ to $K$ in parallel do 5.   Client runs Algorithm 1 to compute $\mathsf{\Delta }{\theta }_k$ 6.   end for 7.   // Aggregate updates (FedAvg) 8.   $N_{\mathrm{total}}={\sum }_{k=1}^K{N}_k$ ($N_k$ = number of flows in domain $k$) 9.   ${\theta }_{{\mathrm{global}}_{\mathrm{new}}}=\left(1/N_{\mathrm{total}}\right){\sum }_{k=1}^K{N}_k\cdot ({\theta }_{\mathrm{global}}+\mathsf{\Delta }{\theta }_k)$ 10. // Optional: q-fairness correction $\left(q≥1\right)$ 11. for each client $k$ do 12. Compute local loss $L_k({\theta }_{{\mathrm{global}}_{\mathrm{new}}})$ using a validation set 13. $w_k=(L_k{)}^{\left(q−1\right)}$ 14. end for 15. if q-fairness applied then 16. ${\theta }_{\mathrm{global}}=\left(1/∑w_k\right)\sum w_k\cdot ({\theta }_{\mathrm{global}}+\mathsf{\Delta }{\theta }_k)$ 17. else 18. ${\theta }_{\mathrm{global}}={\theta }_{{\mathrm{global}}_{\mathrm{new}}}$ 19. end if 20. // Check convergence 21. if $\parallel {\theta }_{\mathrm{global}}-{\theta }_{{\mathrm{global}}_{\mathrm{prev}}}\parallel <{\epsilon }_{\mathrm{global}}$ then 22. break 23. end if 24. end for

Privacy-Preserving Extensions. While FL preserves data locality (raw network state and trust data never leave each domain), formal privacy guarantees—such as differential privacy or secure aggregation—are not implemented in this work. Homomorphic encryption would allow the server to aggregate encrypted gradients without decrypting individual updates, and differential privacy would add calibrated noise to the aggregated model updates, limiting information leakage about any single client. However, these techniques add computational overhead and require careful tuning. We explicitly identify secure aggregation and differential privacy as critical future work to provide rigorous protection against model inversion and gradient leakage attacks. The current framework focuses on the core contribution of combining GNNs, hybrid DRL, and q-fair FL for trust-aware resource allocation.

4.3. Local DRL Training with GNN

For completeness, Algorithm 3 shows the detailed local DRL training loop that runs inside each client (note that this is essentially the inner loop of Algorithm 1). The algorithm explicitly updates the GNN encoder, DQN, and SAC networks using experience replay. The SAC update includes the Critic (value function), Actor (policy), and an automatically tuned temperature parameter $\alpha$ that balances exploration and exploitation.

Algorithm 3: Local GNN-DRL training step (SAC + DQN)

Input: Current state $s$, replay buffer $B$, current parameters $\theta$ (GNN, DQN, SAC with twin Q-functions) Output: Updated parameters ${\theta }^{\prime }$ 1.   $\mathrm{batch}=\mathrm{sample}\text{\_}\mathrm{minibatch}(B,\mathrm{batch}\text{\_}\mathrm{size})$ 2.   for each transition $\left(h_G,a_d,a_c,r,h_{G_{\mathrm{next}}}\right)$ in batch do 3.   // DQN update (discrete actions) 4.   $Q_{\mathrm{target}}=r+\gamma {\mathrm{m}\mathrm{a}\mathrm{x} }_{a^{\prime }}{\mathrm{DQN}}_{{\theta }_{\mathrm{DQN}}}(h_{G_{\mathrm{next}}},a^{\prime })$ 5.   $L_{\mathrm{DQN}}+={\left(Q_{\mathrm{target}}-{\mathrm{DQN}}_{{\theta }_{\mathrm{DQN}}}(h_G,a_d)\right)}^2$ 6.   // SAC update (continuous actions)—Twin Q-functions 7.   // Target value with entropy bonus 8.   $a_{c_{\mathrm{next}}}\sim {\pi }_{{\theta }_{\mathrm{SAC}}}(\cdot \mid h_{G_{\mathrm{next}}})$ 9.   $V_{\mathrm{target}}=\mathrm{m}\mathrm{i}\mathrm{n} (Q_{{\theta }_1^{\prime }}(h_{G_{\mathrm{next}}},a_{c_{\mathrm{next}}}),Q_{{\theta }_2^{\prime }}(h_{G_{\mathrm{next}}},a_{c_{\mathrm{next}}}))-\alpha \mathrm{l}\mathrm{o}\mathrm{g} {\pi }_{{\theta }_{\mathrm{SAC}}}(a_{c_{\mathrm{next}}}\mid h_{G_{\mathrm{next}}})$ 10. // Critic update (twin Q-functions) 11. $L_{\mathrm{SAC}\text{\_}\mathrm{Critic}}+=(r+\gamma V_{\mathrm{target}}-Q_{{\theta }_1}(h_G,a_c){)}^2+(r+\gamma V_{\mathrm{target}}-Q_{{\theta }_2}(h_G,a_c){)}^2$ 12. // Actor update (policy) 13. $a_{c_{\mathrm{new}}}\sim {\pi }_{{\theta }_{\mathrm{SAC}}}(\cdot \mid h_G)$ 14. $L_{\mathrm{SAC}\text{\_}\mathrm{Actor}}+=\alpha \mathrm{l}\mathrm{o}\mathrm{g} {\pi }_{{\theta }_{\mathrm{SAC}}}(a_{c_{\mathrm{new}}}\mid h_G)-\mathrm{m}\mathrm{i}\mathrm{n} (Q_{{\theta }_1}(h_G,a_{c_{\mathrm{new}}}),Q_{{\theta }_2}(h_G,a_{c_{\mathrm{new}}}))$ 15. // Temperature update (entropy tuning) 16. $L_{\alpha }+=-\alpha \mathrm{l}\mathrm{o}\mathrm{g} {\pi }_{{\theta }_{\mathrm{SAC}}}(a_{c_{\mathrm{new}}}\mid h_G)-\alpha {\mathcal{H}}_{\mathrm{target}}$ 17. // Regularisation for GNN 18. $L_{\mathrm{reg}}=\parallel {\nabla }_{\phi }{\parallel }_2^2$ 19. end for 20. $L_{\mathrm{total}}=L_{\mathrm{SAC}\text{\_}\mathrm{Actor}}+L_{\mathrm{SAC}\text{\_}\mathrm{Critic}}+L_{\alpha }+{\lambda }_1{L}_{\mathrm{DQN}}+{\lambda }_2{L}_{\mathrm{reg}}$ 21. ${\theta }^{\prime }\leftarrow \theta -\alpha \nabla L_{\mathrm{total}}$ 22. Update target networks: ${\theta }_i^{\prime }\leftarrow \tau {\theta }_i+(1-\tau ){\theta }_i^{\prime }$ for $i=\mathrm{1,2}$

4.4. Security Robustness Analysis

The federated framework inherently enhances security through distributed trust evaluation and privacy-preserving aggregation. We quantify three security metrics that capture different dimensions of network resilience against adversarial compromise.

Compromise Resistance (CR) is the minimum number of nodes an adversary must compromise to gain control of a critical flow. For a flow $f$ with path $p_f$:

$$C{R}_f=\underset{p\in {\mathcal{P}}_f}{\mathrm{m}\mathrm{i}\mathrm{n}}\mid \{v\in p:\mathrm{compromised}\}\mid .$$

(12)

The overall CR is the minimum over all critical flows. In a multi-domain setting, an adversary must compromise at least one node in each domain along a multi-domain path, increasing CR with the number of domains.

Attack surface (AS) is the number of nodes with trust below the critical threshold ${\theta }_{\mathrm{crit}}$ that are reachable from an initial compromised node without crossing a trust boundary:

$$AS=\mid \{v\in V:T_v<{\theta }_{\mathrm{crit}}\wedge \mathrm{reachable}(v_0,v)\}\mid .$$

(13)

The attack surface shrinks as trust thresholds increase, because fewer nodes are considered sufficiently trustworthy to be accessible.

Lateral movement containment (LMC) is the probability that a compromised node cannot access resources outside its security class:

$$LMC=1-{\displaystyle \frac{{\sum }_{f\in F}\mathbf{1}\{\mathrm{class}(f)\ne \mathrm{class}(v)\wedge v\in {\mathrm{path}}_f\}}{{\sum }_{f\in F}1}}.$$

(14)

Within the federated framework, each domain enforces local micro-segmentation, and the server’s q-fair aggregation prevents any single domain from disproportionately influencing the global model. However, q-fair aggregation alone does not guarantee resistance to poisoning attacks; it only ensures balanced weighting of local losses. The expected resistance to compromise increases with the number of domains, as an adversary must compromise at least one node in each domain along a multi-domain path. The attack surface is reduced because trust thresholds are enforced locally and cross-domain communication requires mutual authentication. Collectively, these mechanisms provide practical security improvements, which are evaluated quantitatively in Section 5.4. It should be noted that these are heuristic security enhancements rather than formal guarantees; rigorous formal security proofs and mechanisms such as differential privacy and secure aggregation remain topics for future work.

4.5. Algorithmic Complexity Analysis

The computational and communication complexity of the proposed framework is critical for assessing its applicability in near-real-time network operations.

Time Complexity (Local Inference): The GNN forward pass has complexity $O(L\cdot (\mid E\mid +\mid V\mid \cdot d))$, where $L$ is the number of GAT layers, $\mid V\mid$ and $\mid E\mid$ are the number of nodes and edges in the domain, and $d$ is the hidden dimension. The DQN and SAC inference steps require $O(N_{\mathrm{params}})$ operations, with $N_{\mathrm{params}}\approx 850$ k in our implementation. The overall per-step inference time is 3.2 ms on an NVIDIA A100 GPU, suitable for near-real-time control.

Training Time: Each local episode runs for $T_{\mathrm{m}\mathrm{a}\mathrm{x}}=1000$ time steps with $M_{\mathrm{local}}=50$ episodes per federated round. Training for $R=200$ rounds requires approximately 6.5 h on a single A100 GPU.

Space Complexity: The replay buffer stores $\mid B\mid ={10}^5$ transitions, each of dimension $\left(d+\mid a_d\mid +\mid a_c\mid \right)$, consuming approximately 1.2 GB of GPU memory.

Communication Complexity: Per federated round, each client uploads a model update of size $\mid \mathsf{\Delta }{\theta }_k\mid \approx 24$ KB (the size of the GNN, DQN, and SAC network parameters). With $K=5$ clients, the total communication overhead is approximately 120 KB per round. This is negligible for a 1 Gbps control link and scales linearly with the number of clients. Even scaling to 50 clients, the overhead would be 1.2 MB per round, which remains acceptable for the typical 10 ms control loop of an O-RAN near-RT RIC.

These complexity figures confirm that the federated GNN-DRL framework is practical for deployment in multi-domain SDN environments, balancing learning capability with acceptable computational and communication costs.

5. Performance Evaluation

We evaluated the proposed federated GNN-DRL framework using a custom discrete event simulator implemented in Python. The network consisted of 100 nodes divided into five domains (each with 20 nodes), based on the Internet2 OS3E topology. Link capacities were 10 Gbps, propagation delays 1–20 ms. Traffic comprised 500 flows per domain with three classes: critical (10%, trust threshold 0.95, latency 5 ms), data (60%, threshold 0.8, latency 20 ms), background (30%, threshold 0.6, best-effort). Trust parameters: $\kappa =0.1, \sigma =0.05, {\mu }_v$ uniform in [0.7, 0.99]. Link failure probability is 0.02 per time step; node failure Poisson rate is 0.005 per second. Simulation time is 1000 s, time step is 0.1 s. Algorithms compared: federated GNN-DRL (proposed), centralised GNN-DRL (ideal upper bound), local GNN-DRL (no federation), baseline (OSPF + static backup paths). Each experiment was repeated 30 times.

5.1. Simulation Setup

The proposed federated GNN-DRL framework was evaluated using a custom discrete event simulator implemented in Python. The network consisted of 100 nodes divided into five domains (each with 20 nodes), modelled after the Internet2 OS3E topology. Link capacities were set to 10 Gbps, propagation delays between 1 and 20 ms. Traffic comprised 500 flows per domain with three service classes: critical (10% of flows, trust threshold 0.95, latency requirement 5 ms), data (60% of flows, trust threshold 0.8, latency 20 ms), and background (30% of flows, trust threshold 0.6, best-effort). Trust evolution followed the stochastic differential equation model with parameters $\kappa =0.1$, $\sigma =0.05$, and baseline trust ${\mu }_v$ uniformly distributed between 0.7 and 0.99. Link failures occurred with probability 0.02 per time step, and node failures followed a Poisson process with rate 0.005 per second. Each simulation ran for 1000 s with a time step of 0.1 s. Figure 6 shows the multi-domain network topology used in our simulations. The 100-node Internet2 OS3E topology is divided into five administrative domains of 20 nodes each, with inter-domain links shown as dashed lines.

Figure 6. Multi-domain network topology: 100-node Internet2 OS3E topology divided into five domains (20 nodes each), coloured by domain. Inter-domain links are shown as dashed lines.

Four algorithms were compared, namely;

• Federated GNN-DRL (proposed): each domain trains a local GNN-DRL agent; model updates are sent to a central server for aggregation using q-fair FL.
• Centralised GNN-DRL (ideal upper bound): a single GNN-DRL agent with access to all network data, no privacy preservation.
• Local GNN-DRL: each domain trains its own GNN-DRL agent independently, without federation.
• Baseline: OSPF routing with precomputed backup paths and no trust adaptation.

All experiments were repeated 30 times with different random seeds; average values are reported.

5.1.1. Implementation and Hyperparameter Details

All experiments were implemented in Python 3.10 with PyTorch 2.1.0 on an NVIDIA A100 GPU with 40 GB of memory. The Adam optimiser was used for all network updates. Hyperparameters were tuned using a combination of grid search (for discrete parameters) and Bayesian optimisation (for continuous parameters) on a 10% validation set (100 s of simulation time). Table 2 summarises the key hyperparameters and model architecture details.

Table 2. Training hyperparameters and model architecture.

Parameter	Value
Optimiser	Adam
Learning rate (GNN, DQN, SAC)	$1\times {10}^{-4}$
Weight decay	$1\times {10}^{-5}$
GNN layers ($L$)	2
GNN hidden dimension	128
Attention heads	4
DQN network structure	2-layer MLP, 256 units each, ReLU activation
SAC Actor network	2-layer MLP, 256 units each, ReLU activation
SAC Critic network	2-layer MLP, 256 units each, ReLU activation
Discount factor ($\gamma$)	0.99
GAE parameter ($\lambda$)	0.95
SAC temperature ($\alpha$)	0.2 (automatically tuned)
SAC target smoothing ($\tau$)	0.005
Exploration schedule (DQN $\epsilon$)	1.0 → 0.01 (decayed over 1000 episodes)
Batch size	256
Replay buffer size	${10}^5$
Local episodes per round ($M_{\mathrm{local}}$)	50
Federated rounds ($R$)	200
Client sampling ratio	1.0 (all clients participate)
Aggregation interval	1 round
Random seed	42 (with 30 different seeds for statistics)
PyTorch version	2.1.0
Python version	3.10
GPU model	NVIDIA A100 (40 GB)
CPU model	Intel Xeon Gold 6248
GPU memory usage	~1.2 GB
Total trainable parameters	~850,000
FLOPs per forward pass	12.3 GFLOPS
Training time (200 rounds)	~6.5 h
Inference latency (per step)	3.2 ms

The reward weights were set to ${\eta }_1=0.5$, ${\eta }_2=0.3$, and ${\eta }_3=0.2$ to balance throughput, trust compliance, and congestion, respectively. The q-fairness parameter was set to $q=2$, following the recommendation in [7] to balance fairness and convergence speed.

5.1.2. Parameter Tuning Methodology

The hyperparameters listed in Table 2 were determined through a systematic tuning process. A 10% subset of the simulation time (100 s) was reserved as a validation set, separate from the training environment. The following procedure was applied:

• Grid search for discrete parameters: The number of GNN layers ($L\in \{1,2,3\}$), attention heads ($\left\{2,4,8\right\}$), and hidden dimensions ($\left\{64,128,256\right\}$) were evaluated using a grid search. The configuration yielding the highest average validation reward was selected ($L=2$, heads = 4, hidden = 128).
• Bayesian optimisation for continuous parameters: Learning rates (${10}^{-5}$ to ${10}^{-3}$), discount factor $\gamma$ ($0.9$ to $0.999$), and reward weights ${\eta }_1,{\eta }_2,{\eta }_3$ were optimised using Bayesian optimisation with a Gaussian process surrogate model. The expected improvement (EI) acquisition function was used for 50 iterations. The optimal values are reported in Table 2.
• Trust parameters: The trust evolution parameters ($\kappa =0.1$, $\sigma =0.05$, ${\mu }_v\in [0.7, 0.99]$) were set based on empirical network behaviour studies and CVSS distributions from the National Vulnerability Database (NVD), ensuring they reflect realistic network conditions.
• Validation: The tuned hyperparameters were then validated on a separate 10% hold-out set to confirm no overfitting to the validation data.

This systematic tuning ensures that the reported performance results are not contingent on arbitrary parameter choices and can be reproduced independently.

5.2. Simulation Results

Figure 7 presents the average throughput (Gbps) as a function of offered load (Gbps) for the four evaluated algorithms. The proposed federated GNN-DRL framework maintains near-ideal throughput up to 80 Gbps, with a throughput of 76.2 Gbps at this load, representing only a 4.8% drop from the ideal line. At 90 Gbps, the federated approach delivers 83.5 Gbps, which is within 2% of the centralised upper bound (85.0 Gbps). In contrast, the local-only method drops to 69.5 Gbps at 80 Gbps (a 13% drop from the ideal) and 74.0 Gbps at 90 Gbps.

Figure 7. Throughput vs. load: FL approaches centralised performance.

The baseline collapses earlier, delivering only 61.0 Gbps at 80 Gbps and 63.0 Gbps at 90 Gbps, a 37% drop from the ideal at high load. The better performance of federated GNN-DRL stems from two factors: (1) the GNN encoder captures distant dependencies and failure propagation patterns that are invisible to local-only agents, and (2) the server-side q-fair aggregation stops any single domain from controlling the global model, thus balancing load across all domains. The gap between federated and centralised (only 1.5 Gbps at 90 Gbps) demonstrates that FL imposes a negligible performance penalty while retaining data privacy.

Figure 8 shows the average recovery time (ms) after a single link failure as a function of offered load. The federated GNN-DRL achieves a recovery time of 42 ms at 60 Gbps load, which is 53% lower than the baseline (90 ms) and 19% lower than local-only (52 ms). Centralised achieves 38 ms, only 4 ms faster than federated. At higher loads (80 Gbps), recovery times increase for all methods due to increased contention, but federated still maintains a 50% advantage over the baseline (55 ms vs. 125 ms). The improvement is credited to the GNN’s ability to predict failure propagation: the attention mechanism detects crucial links, and the DRL agent pre-emptively reroutes flows before the failure fully propagates. The local-only method, lacking global topology awareness, must rely on local rerouting, which takes longer. The small gap between federated and centralised (4 ms) is a small price for privacy.

Figure 8. Average recovery time (ms) after a single link failure.

Figure 9 illustrates the trust violation rate (%) as a function of the link failure rate (%). Under normal conditions (0% failures), all methods maintain trust violations below 0.5%, confirming that the trust-aware reward function is effective. At 40% failure rate, the baseline, which has no trust adaptation, suffers 18% violations because compromised nodes are not isolated. Local-only, which uses local trust scores, limits violations to 6.5% but cannot account for trust propagation from other domains. Federated GNN-DRL reduces violations to 4.2% by sharing trust model updates across domains, thereby improving trust estimation for nodes that have low local data. Centralised reaches 3.1%, but the difference between federated and centralised is only 1.1 percentage points at the highest failure rate, demonstrating that federated trust learning is highly effective. The trust violation rate is crucial for ZT compliance; the results show that federated GNN-DRL meets the strict requirement of <5% violations even under severe network disruptions.

Figure 9. Trust violation rate (%) as a function of link failure rate.

Figure 10 presents the resilience metric, defined as the fraction of delivered traffic, as a function of the number of simultaneous link failures. Resilience refers to the percentage of total offered traffic that successfully reaches its destination. In the absence of failures, all methods deliver more than 99% of traffic. As the number of failures increases, resilience declines. For 20 simultaneous failures, which represents a moderate yet realistic scenario, the baseline method delivers only 72% of traffic due to OSPF’s slow path recalculation and lack of trust integration. The local-only approach, utilising local GNN-DRL, achieves 82%. Federated GNN-DRL delivers 88%, while the centralised approach achieves 91%. The 16-percentage-point difference between the federated and baseline approaches (88% versus 72%) represents a 22% relative improvement in traffic delivery. Under the extreme condition of 50 simultaneous failures, federated GNN-DRL delivers 68% of traffic, compared to 58% for the local-only approach and 45% for the baseline. The GNN’s capacity to model cascade failures, as illustrated in Figure 4, enables the agent to proactively reroute traffic around failure hotspots, a capability not present in the heuristic baseline.

Figure 10. Resilience metric (fraction of delivered traffic) as a function of simultaneous link failures.

Figure 11 presents the training convergence of the FL process, measured as cumulative reward per episode against the number of federated rounds. The q-fair FL variant (q = 2) achieves convergence after approximately 120 rounds with a reward of 0.82. In contrast, standard FedAvg converges more slowly, reaching a reward of 0.76 after 180 rounds, while the local-only approach (no federation) plateaus at 0.68 after 200 rounds. The accelerated convergence observed in q-fair FL results from upweighting domains with higher local loss, compelling the global model to prioritise underperforming domains. This approach mitigates the dominance of domains with larger datasets, which would otherwise disproportionately influence FedAvg. The improvement in final reward (0.82 versus 0.76) constitutes an 8% increase in cumulative reward, indicating enhanced QoS satisfaction across domains. The plateau of the local-only baseline at 0.68 demonstrates that, without federation, individual domains are unable to leverage the collective intelligence of the entire network.

Figure 11. Training convergence: cumulative reward per episode vs. federated rounds.

Figure 12 presents the average end-to-end delay for critical (URLLC) flows as a function of offered load. At low load (20 Gbps), all methods attain delays below 2 ms. As load increases, the baseline delay spikes because the decoupled DBA and PRB schedulers cause queuing at ONUs. At 80 Gbps, baseline delay reaches 18 ms, far exceeding the URLLC requirement of 5 ms. Local-only, with its local GNN-DRL, achieves 6.2 ms at 80 Gbps, still above the requirement. Federated GNN-DRL stays at 4.8 ms, satisfying the URLLC constraint. Centralised achieves 4.2 ms. The federated framework’s ability to maintain low delay stems from the joint optimisation of DBA and PRB allocation, which prevents grant-queue misalignment. The short-delay performance is vital for applications such as remote surgery and autonomous driving, which depend on optical backhaul.

Figure 12. Average end-to-end delay for critical (URLLC) flows.

Figure 13 compares the Jain’s fairness index across the three QoS classes (URLLC, eMBB, mMTC). The baseline, which uses proportional fair scheduling without trust adaptation, achieves a fairness index of only 0.78, indicating that eMBB flows often starve URLLC or mMTC. Local-only improves to 0.86 because its DRL agent learns to balance resources locally, but it cannot coordinate across domains. Federated GNN-DRL achieves 0.92, very close to the centralised upper bound of 0.94. The high fairness is due to the multi-objective reward function, which includes terms that penalise starvation of any class, and the q-fair aggregation that balances contributions from domains with different traffic mixes. This ensures that even a domain dominated by mMTC traffic still receives a fair share of resources.

Figure 13. Jain’s fairness index across QoS classes (URLLC, eMBB, mMTC).

Plotted in Figure 14 is the communication overhead (KB per federated round) as a function of the number of clients. Overhead scales linearly because each client sends a model update of approximately 24 KB (the size of the GNN and Actor-Critic network parameters). With five clients (as in our simulation), the total overhead is 120 KB per round. At a typical federated round duration of 1 s, this consumes only 0.96 Mbps of control plane bandwidth, well within the capacity of a 1 Gbps link. Even scaling 50 clients, the overhead would be 1.2 MB per round, still negligible. This low overhead makes the framework suitable for near-real-time operation on the O-RAN near-RT RIC, which typically has a 10 ms control loop but can accommodate longer intervals for federated aggregation.

Figure 14. Communication overhead (KB per federated round) as a function of number of clients.

5.3. Ablation Studies

To isolate the contribution of each component of the proposed framework, we conducted systematic ablation experiments under a fixed scenario of 60 Gbps offered load and 20% link failure rate. Eight variants of the proposed framework were evaluated, each removing or replacing a specific module. The results are summarised in Table 3 and visualised in Figure 15.

Table 3. Ablation study results: performance degradation relative to the full model.

Variant	Throughput Drop (%)	Recovery Time Increase (%)	Trust Violation Increase (×)	Resilience Drop (%)
Full model (Federated GNN-DRL)	—	—	—	—
w/o GNN (MLP encoder instead)	12%	18%	2.1×	8%
w/o trust-aware reward	8%	10%	3.0×	6%
w/o failure propagation modelling	15%	28%	1.5×	12%
FedAvg (instead of q-fair)	6%	5%	1.2×	4%
DQN only (no continuous actions)	18%	22%	1.4×	14%
SAC only (no discrete actions)	10%	35%	1.3×	9%
No FL (local-only)	22%	19%	2.5×	16%
w/o security constraint in reward	4%	8%	1.8×	5%

Figure 15. Ablation study: percentage degradation for each variant relative to the full model.

Key findings from the ablation experiments:

• GNN encoder is the most critical component: removing it (using a simple MLP) causes a 12% throughput drop and an 8% resilience drop, confirming that topology awareness is essential for failure propagation modelling.
• Trust-aware reward: Removing this component increases trust violations by a factor of 3, demonstrating its importance for maintaining ZT compliance.
• Failure propagation modelling: Without it, recovery time increases by 28%, indicating that proactive failure prediction is vital for fast rerouting.
• q-fair aggregation: Replacing q-fair with standard FedAvg reduces throughput by 6% and increases trust violations by 20%, highlighting the importance of fairness-aware aggregation across heterogeneous domains.
• Hybrid DQN-SAC design: Using only DQN (no continuous actions) causes an 18% throughput drop, while using only SAC (no discrete actions) increases recovery time by 35%. Both are needed for joint discrete continuous optimisation.
• FL: Without federation (local-only training), throughput drops by 22% and trust violations increase by 2.5×, confirming that cross-domain collaboration significantly improves performance.
• Security constraint: Removing the security robustness constraint from the reward has a modest effect on throughput (4% drop) but increases trust violations by 80%, confirming that the security constraint primarily enhances trust compliance without sacrificing performance.

These ablation results confirm that each module contributes meaningfully to the overall performance and security of the proposed federated GNN-DRL framework.

5.4. Security Robustness Results

Figure 16 presents compromise resistance (CR) as a function of the number of domains. CR represents the minimum number of nodes that an adversary must compromise to disrupt a critical flow. In the single-domain scenario, federated GNN-DRL achieves a CR of 2, indicating that at least two nodes on the critical path must be compromised. When the number of domains increases to 5, CR rises to 7, as the adversary must compromise at least one node in each domain along a multi-domain path, in addition to extra nodes to bypass redundancy. In comparison, the centralised approach yields a maximum CR of 3 within a single domain, the local-only approach achieves 2.5, and the baseline is 1. The elevated CR in the federated framework results from its distributed trust evaluation: each domain enforces its own trust thresholds, and cross-domain traffic requires mutual authentication. Consequently, adversaries face significant barriers to lateral movement across domains.

Figure 16. Compromise resistance (minimum nodes to compromise) as a function of number of domains.

Figure 17 illustrates the attack surface as a function of the trust threshold. The attack surface is the number of nodes with trust below the threshold that are reachable from an initial compromise without crossing a trust boundary. At a low threshold (0.7), many nodes are considered acceptable, and the federated attack surface is 32 nodes (out of 100). As the threshold increases to 0.95, only the most trusted nodes (those with CVSS scores below 0.5) remain accessible, reducing the attack surface to four nodes, which is an overall 87% reduction. The baseline, which has no trust-based isolation, always has an attack surface of 98 nodes (all but the initial compromised node). Centralised achieves eight nodes at 0.95, and local-only 12 nodes. The federated framework’s smaller attack surface stems from cross-domain trust propagation: a node’s trust score is influenced not only by its own behaviour but also by its neighbours in other domains, making it harder to remain in the trusted set after a compromise.

Figure 17. Attack surface (number of reachable low-trust nodes) as a function of trust threshold ${\theta }_{\mathrm{crit}}.$

Figure 18 illustrates lateral movement containment (LMC) as a function of the number of security classes. LMC represents the probability that a compromised node cannot access resources outside its assigned security class. When only one security class is present (i.e., no segmentation), LMC is 60% for the federated approach, which is an improvement over the baseline value of 50%. As the number of security classes increases to five, the federated method achieves 98% containment, indicating that a compromised node in class 2 has only a 2% probability of accessing resources in class 1 or 3. The centralised approach reaches 92%, local-only achieves 85%, and the baseline attains 72%. The enhanced containment provided by federated GNN-DRL results from two primary factors: first, each domain enforces micro-segmentation locally using its trust scores; second, cross-domain traffic requires mutual authentication, which is mediated by the server and involves verification of the trust class for both the source and destination. This dual-layer security architecture significantly impedes lateral movement.

Figure 18. Lateral movement containment probability as a function of number of security classes.

Figure 19 shows a Radar chart comparing four algorithms across eight normalised metrics: throughput, recovery time (inverted), trust violation (inverted), fairness, resilience, compromise resistance, attack surface (inverted), and lateral movement containment. Each metric is normalised to the best value across all algorithms (a score of 1). Federated GNN-DRL achieves the highest or near-highest scores across all metrics, approaching the centralised upper bound while preserving privacy.

Figure 19. Radar chart of normalised performance and security metrics.

Overall, the simulation demonstrates that the proposed federated GNN-DRL framework consistently outperforms local-only and baseline methods across all performance and security metrics, while approaching the ideal centralised upper bound. The key findings are summarised as follows. First, FL with q-fair aggregation achieves 97% of centralised throughput at high load (80 Gbps) and reduces recovery time by 53% compared to the baseline, with only a 4 ms increase over centralised. Second, the trust-aware reward function and cross-domain model updates keep trust violations below 5% even under 40% failure rates, meeting ZT requirements. Third, resilience under massive failures (50 simultaneous link failures) remains high at 68% traffic delivery, outperforming local-only by 10% and baseline by 30%. Fourth, the framework guarantees near-perfect fairness (0.92) across QoS classes, ensuring that URLLC, eMBB, and mMTC slices are not starved. Fifth, security robustness metrics show that federated GNN-DRL provides compromise resistance for seven nodes (vs. 1 for the baseline), reduces the attack surface to four nodes (vs. 98), and achieves 98% lateral movement containment across five security classes. Communication overhead is modest (120 KB per round for five clients), enabling deployment on the near-RT RIC. In summary, the federated GNN-DRL framework closes the long-standing gap between centralised optimality and local privacy, offering a practical, scalable, and secure solution for multi-domain ZT SDN networks.

6. Conclusions

This work presents a federated graph neural network-enhanced deep reinforcement learning framework for resilient, trust-aware resource allocation in Zero Trust Software-Defined Networking (ZT SDN) environments. The framework enables multiple administrative domains to collaboratively learn optimal resource allocation policies without sharing raw network state or trust data. Three pseudo-code algorithms detail the client-side training (Algorithm 1), server-side q-fair aggregation (Algorithm 2), and local deep reinforcement learning (DRL) updates (Algorithm 3). Four model graphs depict the evolution of trust, propagation dynamics, graph neural network (GNN) attention mechanisms, and failure cascades. Security robustness is evaluated using metrics such as compromise resistance, attack surface, and lateral movement containment.

Extensive simulations conducted on a 100-node topology, partitioned into five domains, demonstrate that the federated framework reduces recovery time by 53%, increases throughput under failure conditions by 32%, and maintains trust violation rates below 1.8% for low-to-moderate failure scenarios (≤20%). Under severe failure conditions (40%), trust violations remain at 4.2%, which is within the strict 5% Zero Trust compliance threshold. The framework achieves a compromise resistance of seven nodes, reduces the attack surface to four nodes, and attains 98% containment of lateral movement. Overall, the framework’s performance closely approximates that of a centralised ideal while preserving data locality.

Security and Privacy Limitations: The reported security metrics, including compromise resistance, attack surface, and lateral movement containment, serve as empirical heuristics to quantify practical robustness against specific attack scenarios. These metrics do not provide formal security guarantees. Although the framework preserves data locality by retaining raw data within each domain, it does not implement formal privacy protections such as differential privacy or secure aggregation. The q-fair aggregation method ensures balanced weighting of local losses but does not guarantee resistance to poisoning attacks or Byzantine faults. Mutual authentication and cross-domain security mechanisms are assumed to be provided by the underlying Zero Trust infrastructure.

Future Work: Subsequent research will incorporate differential privacy and secure aggregation to provide formal privacy protection against model inversion and gradient leakage attacks. The framework will also be extended to support asynchronous federated learning, integrate quantum-resistant cryptographic mechanisms for authentication, and undergo validation on a physical testbed.