Enabling Trustworthy Federated Learning via Remote Attestation for Mitigating Byzantine Threats

TL;DR

This paper introduces Sentinel, a remote attestation-based system that enhances trust in federated learning by verifying the integrity of local training processes to mitigate Byzantine threats effectively.

Contribution

Sentinel is the first system to apply remote attestation and code instrumentation for verifying training integrity in federated learning, reducing false positives and improving security.

Findings

Ensures training process integrity with low overhead.

Effectively detects malicious client behavior.

Maintains high accuracy in Byzantine attack mitigation.

Abstract

Federated Learning (FL) has gained significant attention for its privacy-preserving capabilities, enabling distributed devices to collaboratively train a global model without sharing raw data. However, its distributed nature forces the central server to blindly trust the local training process and aggregate uncertain model updates, making it susceptible to Byzantine attacks from malicious participants, especially in mission-critical scenarios. Detecting such attacks is challenging due to the diverse knowledge across clients, where variations in model updates may stem from benign factors, such as non-IID data, rather than adversarial behavior. Existing data-driven defenses struggle to distinguish malicious updates from natural variations, leading to high false positive rates and poor filtering performance. To address this challenge, we propose Sentinel, a remote attestation (RA)-based scheme for FL systems that regains client-side transparency and mitigates Byzantine attacks from a system security perspective. Our system employs code instrumentation to track control-flow and monitor critical variables in the local training process. Additionally, we utilize a trusted training recorder within a Trusted Execution Environment (TEE) to generate an attestation report, which is cryptographically signed and securely transmitted to the server. Upon verification, the server ensures that legitimate client training processes remain free from program behavior violation or data manipulation, allowing only trusted model updates to be aggregated into the global model. Experimental results on IoT devices demonstrate that Sentinel ensures the trustworthiness of the local training integrity with low runtime and memory overhead.

Tables

Table 1. TABLE I: Targeted Byzantine Resilience Performance in FL: Evaluated by Global Model Test Accuracy and Attack Success Rate Triggered by Crafted Inputs under IID and Non-IID Settings.

Attack	Dataset	FedAvg	Krum	Coomed	TrimmedMean	Bulyan	FLTrust	Sentinel
		Acc/ASR	Acc/ASR	Acc/ASR	Acc/ASR	Acc/ASR	Acc/ASR	Acc/ASR
T-CF-krum	FMNIST (IID)	91.7/8.4	88.0/97.8	91.8/44.1	91.6/43.9	91.4/71.2	91.6/39.6	91.3/0.0
	FMNIST (non-IID)	87.2/18.4	83.5/99.5	87.0/59.0	87.3/55.0	87.2/81.0	88.5/49.5	89.5/0.0
	CIFAR-10 (IID)	68.5/25.9	48.9/99.5	67.9/44.3	68.1/35.7	67.3/66.0	66.9/1.7	66.6/0.0
	CIFAR-10 (non-IID)	63.5/38.5	45.0/99.9	63.0/59.5	63.0/44.0	62.5/76.0	64.0/28.3	64.5/0.0
T-DO-krum	FMNIST (IID)	91.7/57.8	87.8/98.7	91.9/77.9	91.5/67.5	91.4/85.2	91.6/0.1	91.4/0.0
	FMNIST (non-IID)	87.2/70.5	83.0/99.8	87.1/89.5	87.0/80.0	86.8/93.5	88.5/5.0	89.2/0.0
	CIFAR-10 (IID)	68.2/55.3	50.5/97.9	67.7/81.2	67.5/54.8	66.3/89.1	66.7/5.3	65.7/0.0
	CIFAR-10 (non-IID)	63.2/67.8	45.5/99.9	63.0/93.0	62.8/69.0	62.0/95.0	63.2/26.5	63.0/0.0

Table 2. TABLE II: Untargeted Byzantine Resilience Performance in FL: Evaluated Based on Global Model Test Accuracy under IID and Non-IID Settings.

Attack	Dataset	FedAvg	Krum	Coomed	TrimmedMean	Bulyan	FLTrust	Sentinel
UNT-CF-krum	FMNIST (IID)	59.4	7.5	79.8	89.5	86.5	90.8	91.0
	FMNIST (non-IID)	56.0	5.0	75.5	86.0	83.5	88.5	89.2
	CIFAR-10 (IID)	59.1	11.0	68.5	68.4	68.3	66.4	67.2
	CIFAR-10 (non-IID)	57.5	6.5	58.0	58.0	60.0	63.5	64.8
UNT-DO-krum	FMNIST (IID)	87.3	88.3	80.5	60.7	89.6	90.9	91.1
	FMNIST (non-IID)	84.0	85.5	77.0	58.0	86.0	89.0	90.5
	CIFAR-10 (IID)	58.8	88.5	69.0	61.5	68.6	66.8	67.4
	CIFAR-10 (non-IID)	56.0	84.0	65.5	49.5	60.0	61.5	65.0

Equations

$${\theta }^{(t+1)}\leftarrow \frac{1}{|V|}\sum _{i\in \{C_i\}{|}_{i\in [V]}}{\delta }_i^{(t)}.$$

Full text

To address this challenge, we propose Sentinel, a remote attestation (RA)-based scheme for FL systems that regains client-side transparency and mitigates Byzantine attacks from a system security perspective. Our system employs code instrumentation to track control-flow and monitor critical variables in the local training process. Additionally, we utilize a trusted training recorder within a Trusted Execution Environment (TEE) to generate an attestation report, which is cryptographically signed and securely transmitted to the server. Upon verification, the server ensures that legitimate client training processes remain free from program behavior violation or data manipulation, allowing only trusted model updates to be aggregated into the global model. Experimental results on IoT devices demonstrate that Sentinel ensures the trustworthiness of the local training integrity with low runtime and memory overhead.

I Introduction

Federated Learning is widely recognized for its privacy-preserving capabilities, enabling decentralized local clients to collaboratively train a global model without sharing raw data [1, 2]. In mission-critical environments, FL enables collaborative intelligence by allowing heterogeneous nodes, such as satellites, UAVs, and maritime sensors, to jointly train models for disaster response and remote surveillance without requiring local data collection [3, 4]. Similarly, underwater military operations benefit from FL through the efficient coordination of Internet of Underwater Things devices, which must operate under extreme communication and energy constraints [5, 6]. FL also plays a critical role in defending decentralized infrastructure, such as power and communication systems, by enabling distributed anomaly detection while preserving data locality and ensuring robustness against cyber threats [7, 8, 9, 10]. Furthermore, in satellite-based remote sensing, FL supports fine-grained object recognition and target classification from geographically distributed training with proprietary datasets [11, 12].

Despite its advantages, the distributed nature of FL introduces significant security vulnerabilities [13, 14, 15, 16, 17, 18, 19], such as Byzantine attacks, which are further amplified in mission-critical systems. Since the central server trusts remote clients to execute training correctly and use genuine data, compromised participants can exploit this trust. Byzantine nodes can degrade model performance or inject backdoors into the global model by directly manipulating their model updates (model poisoning attacks) or by using carefully crafted datasets (data poisoning attacks) [13, 14, 15, 16, 17].

To address Byzantine attacks in FL, many studies adopt data-driven approaches to identify and filter potentially malicious model updates before aggregation, as illustrated in Fig. 1. However, this remains difficult due to the inherent heterogeneity of local data, making it hard to distinguish benign drifts from adversarial manipulations. Traditional Byzantine-resilient methods rely on outlier detection, assuming malicious updates are separable in a common feature space [20, 21, 22], as shown in Fig. 1(a). Techniques include analyzing gradient angular distance [21], using low-dimensional embeddings [22], and evaluating accuracy on synthetic data [23]. While effective under IID settings, these methods degrade under non-IID conditions [24, 25], where legitimate updates from diverse clients may be misclassified as outliers, as shown in Fig. 1(b). As a result, benign updates may be discarded or stealthy malicious ones accepted, reducing model performance or introducing backdoors [24, 25, 26, 27, 15].

To enhance trustworthiness in mission-critical FL, we propose Sentinel, an RA-based framework that enhances client-side transparency from a system security perspective. RA allows a verifier to validate the integrity of software running on a remote device. In a typical RA protocol, the prover generates a cryptographic measurement, signed with a hardware-protected key, and sent to the verifier. This ensures the device runs the expected code and prevents report forgery. RA can be implemented using dedicated hardware (e.g., TEE) or CPU-based mechanisms. Our approach uses RA as a complementary solution to data-driven defenses, enabling verifiable client training in FL. The proposed framework comprises four key steps:

① Code Instrumentation: To generate a trusted attestation report, our framework instruments the original training source code to track control-flow and monitor critical variables during local training. ② Runtime Training Measurement: To ensure measurement integrity, our design leverages a TEE as the root of trust. We introduce a trusted training recorder that dynamically records control-flow traces, monitors critical variable usage, and ensures the trustworthiness of execution reports sent to the task owner. ③ Attestation Report Generation: To prevent forgery, the measurement engine signs execution data with its TEE signing key before transmission. The attestation report includes control-flow, critical variables usage, and a pre-issued challenge for the current FL iteration, with this signature. This attestation report is securely forwarded to the parameter server along with the model updates. ④ Training Verification: The server verifies the local training process by analyzing execution paths and ensuring control-flow integrity (comparing recorded execution with expected logic) and data integrity (validating critical variable usage). If anomalies are detected, the corresponding model updates are flagged as potentially compromised and excluded from the current iteration’s model aggregation.

By enforcing execution integrity on the client side, our approach avoids blindly trusting remote clients, reducing the attack surface and mitigating the potential Byzantine attacks that tamper with the training process. The key contributions of this work are summarized below:

• •

System-Oriented Byzantine Defense via RA: We propose an RA-based framework for mission-critical or military FL that complements data-driven defenses by verifying local training integrity before model updates are accepted, mitigating both model and data poisoning attacks.

• •

Trusted Execution Measurement: A trusted training recorder continuously monitors runtime execution, capturing control-flow traces and critical variable usage to detect adversarial manipulations and eliminate blind trust in clients.

• •

Verifiable Aggregation Without Heuristic Filtering: Instead of relying on statistical filtering, our verification engine ensures only valid updates are aggregated by analyzing attestation reports for control and data integrity.

• •

Robustness With Low Overhead: We prototype Sentinel on Raspberry Pi V devices. Evaluation shows it effectively defends against runtime-level Byzantine attacks with minimal overhead in execution time and memory usage, significantly improving FL robustness.

II Related Work

As security and privacy of network communication systems evolve [28, 29, 30, 31, 6, 9, 10, 32, 4], the RA is increasingly critical. RA has been applied to FL systems for various security purposes. DeepAttest [33] embeds device-specific fingerprints in model weights, allowing TEEs to verify model legitimacy and prevent misuse. PPFL [34] extends this by deploying TEEs on both clients and servers to protect updates from adversarial manipulation, mitigating passive attacks like data reconstruction and membership inference. SEAR [35] uses Intel SGX [36] for secure aggregation, requiring clients to attest the server’s enclave before encrypting and submitting updates, preventing even honest-but-curious servers from recovering raw data. On the client side, an integrity-preserving FL scheme [37] enforces protocol compliance by reproducing part of training inside a TEE and generating attestation reports, enabling the server to detect deviations like skipped updates or injected gradients. Additionally, several efforts focus on improving scheme efficiency [38, 39, 40].

Unlike prior work, which uses built-in TEE attestation services and tailors training to fit lightweight TEE constraints, we propose a customized RA scheme for FL that leverages the TEE as a root of trust for training process measurement. Our design follows the same TEE assumptions and usage as state-of-the-art RA frameworks [41, 42, 43, 44, 32].

III System Model and Threat Model

III-A System Model

We consider an FL system consisting of four main entities: the task owner, a set of FL clients $\{C_{i}\}|_{i\in[n]}$ (where $[n]\coloneqq\{1,2,...,n\}$), trusted training recorders, and verification engines. The task owner develops the FL system and implements the local training process. They define the model architecture, specify the local training protocol, and manage global model distribution and collection. The task owner also implements RA through code instrumentation in the local training process, enabling runtime measurement. Each FL client performs local training on its private dataset, collected during mission operation, while the training process is recorded to ensure integrity.

In a typical FL training iteration $t$, the task owner distributes the global model weights $\theta^{(t)}$. Each client $C_{i}$ initializes local model weights $\mathbf{w}_{i}\in\mathcal{W}\subseteq\mathbb{R}^{d}$, where $\mathcal{W}$ is the parameter space and $d$ denotes the model dimensionality. The client then computes model updates $\delta_{i}^{(t)}$ in iteration $t$ in the form of weights or gradients for aggregation. Upon successful remote attestation of the local client, the task owner collects model updates $\{\delta_{i}^{(t)}\}_{i\in[v]}$ from selected clients and leverages the parameter server for model aggregation:

[TABLE]

The updated global model $\theta^{(t+1)}$ is then sent back to clients for the next FL iteration, and this process repeats until convergence. For measurement, each client is equipped with a trusted training recorder implemented within the TEE. For verification, the task owner collects attestation measurements from FL clients to validate the legitimacy of control-flow execution and the usage of critical variables.

III-B Threat Model

In Sentinel, we consider the mission-critical FL scenario with the trustworthiness issue of local training as the key priority, where clients execute local training in a complex and untrusted environment, such as a battlefield.

The adversary in this work consists of Byzantine attackers who exploit software stack vulnerabilities to compromise the devices of FL clients deployed in military operations. These attackers violate the legitimate local training process to launch model or data poisoning attacks, aiming to degrade the global model’s utility or inject backdoors.

We assume the task owner is a trusted entity that does not blindly trust remote training integrity and is responsible for verifying attestation reports and aggregating updates only from verified clients. The trusted computing base includes code instrumentation, the system enforcing it (e.g., privileged code managing the MMU or MPU [45]), the TEE, and the underlying hardware. Specifically, the TEE, such as ARM TrustZone [46], serves as the root of trust, ensuring secure collection, storage, and signing of attestation reports. The measurement engine is assumed to be tamper-resistant and correctly implemented. While our method does not directly defend against physical access attacks (e.g., sensor/input-based side channels or hardware fault injections), it may help identify such threats by detecting anomalies in execution patterns. A full defense against physical attacks requires further investigation.

Sentinel is designed to detect remote program behavior violations, including control-flow hijacking and critical variable misuse during local training. It enhances transparency in the training process, eliminating blind trust in potentially compromised clients. Sentinel complements existing data-driven approaches by adding a system-level layer of Byzantine resilience.

IV Design of Sentinel

IV-A Overview

To enable trustworthy FL in mission-critical and military scenarios, we design an RA framework that enables verifiable local training, eliminating blind trust in remote clients. Sentinel enforces control-flow integrity by recording forward-edge jumps/calls and return edges, ensuring clients follow the expected execution path. It also monitors critical variables, such as training data, model weights, gradients, and loss, to defend against data-only attacks.

Sentinel workflow begins with the task owner, who implements the FL system, including server-side coordination and the on-device client application, while integrating the RA scheme into the workflow. To enable verifiable training on remote devices, the task owner instruments the source code to monitor the control-flow graph $\mathcal{CF}_{i}$ and critical variable usage $\mathcal{CV}_{i}$, capturing both forward and backward edges to detect unauthorized re-directions. At the start of each training iteration $t$, client $C_{i}$ receives the global model weights $\theta^{(t)}$ and a unique attestation challenge $ch_{i}$, initializing local weights $\mathbf{w}_{i}\in\mathcal{W}\subseteq\mathbb{R}^{d}$. The client then performs local training and computes model updates $\delta_{i}^{(t)}$. A trusted training recorder, implemented within a TEE, captures $\mathcal{CF}_{i}$ and $\mathcal{CV}_{i}$ during execution. At the end of the iteration, the client signs an attestation report, bound to $ch_{i}$, using its TEE key $sk_{i}$, and sends the signed report along with $\delta_{i}^{(t)}$ to the task owner. The verification engine authenticates the report, checks its integrity, and analyzes the control-flow for hijacking and variable usage for unauthorized modifications indicative of data-only attacks.

Only attestation reports that pass all verification checks are deemed valid, and their corresponding model updates are aggregated into the global model, computed as $\theta^{(t+1)}$. The updated global model is then redistributed to clients for the next training iteration. By integrating RA into the FL pipeline, our framework prevents compromised clients from contributing malicious updates. The use of a TEE ensures tamper-proof attestation, while private key signing of the report, including the unique challenge, prevents forgery. This guarantees that only verifiable and trustworthy contributions are included, significantly enhancing the transparency and robustness of the FL system.

IV-B Remote Attestation Design

We further illustrate how the RA scheme is integrated into the FL system in Fig. 2.

Code Instrumentation: To generate trusted attestation reports, our framework instruments the training application’s source code to monitor control-flow execution and critical variable usage on remote devices.

We directly track the control-flow graph $\mathcal{CF}_{i}$ of each client $C_{i}$, including forward jumps/calls, return points, and conditional branches, to ensure execution adheres to the expected flow and prevent unauthorized redirection. Unlike prior work, our design avoids using cryptographic hashes of return addresses or full control-flow traces for verification [47]. This is motivated by the FL setting, where many clients perform short training sessions over a few epochs, and a central server must verify a high volume of reports.

In contrast to traditional cyber-physical systems, where frequent interrupts, callbacks, and dynamic control transfers make hash-based attestation beneficial [47, 43, 44], FL training is structured and iterative, with relatively static control-flow. Operations like forward/backward passes, gradient updates, and optimizer steps produce return instructions mainly at epoch boundaries or key computation points. Given this predictable execution, recording the full control-flow graph is both feasible and efficient, eliminating the overhead of hash chain reconstruction. This enables fast, deterministic verification and reliable detection of control-flow hijacking.

For critical variable usage $\mathcal{CV}_{i}$, we monitor two categories. The first includes static variables, such as training hyperparameters, e.g., learning rate, batch size, and the loaded dataset, which are configured as read-only before training begins. The second category includes dynamic variables, model weights, gradients, and loss, where we monitor dependencies and usage to detect tampering. All measurements are securely stored by a parallel trusted training recorder within the TEE, ensuring they cannot be manipulated or forged by Byzantine attackers.

Runtime Training Measurement: In each FL training iteration $t$, the task owner distributes global model weights $\theta^{(t)}$ to participating clients. Each client $C_{i}$ securely initializes its local model weights as $\mathbf{w}_{i}\leftarrow\theta^{(t)}$ in preparation for local training. This training phase consists of sequential control-flow and data-flow steps, where each step depends on the correctness of the preceding one.

Each client $C_{i}$ begins by loading a batch of local training data $x_{i}=[x_{i}^{0},x_{i}^{1},\cdots,x_{i}^{m}]$, where $m$ is the local batch size. The model processes the input across layers to compute a predicted output $\hat{y}_{i}$, completing the forward propagation. During this stage, the TEE records key training variables and operations, including the loading of input data and the layer-by-layer computation of intermediate representations $[z_{i}^{(1)},z_{i}^{(2)},\cdots,z_{i}^{(l)}]$, where $l$ denotes the number of layers.

Next, the client performs backward propagation to compute gradients $g_{i}$ and update parameters $\mathbf{w}_{i}$. The predicted output $\hat{y}_{i}$ is compared to ground-truth labels $y_{i}$ using a loss function $L(\hat{y}_{i},y_{i})$, which is back-propagated through the network via the chain rule. The TEE records gradient computations and relevant variables at each layer. Since each layer’s gradients depend on the outputs of preceding layers, any tampering in backward propagation can be detected through inconsistency in later layers.

The final gradient $\nabla\mathbf{w}_{i}$ is used to update model weights as $\mathbf{w}_{i}\leftarrow\mathbf{w}_{i}-\eta\nabla\mathbf{w}_{i}$, where $\eta$ is the learning rate. This process repeats over multiple epochs on the client’s local dataset $\mathcal{D}_{i}$ until the model update $\delta_{i}^{(t)}$ is produced. Throughout the training, the trust engine securely stores control-flow measurements $\mathcal{CF}_{i}$ and critical variable usage $\mathcal{CV}_{i}$. In practice, these measurements are implemented using Secure Monitor Calls in ARM TrustZone [46].

Attestation Report Generation: A malicious client may attempt to replay a previously valid model update from an earlier round to deceive the server. To prevent this, the attestation report must include a freshness guarantee, ensuring that each attestation is uniquely bound to a specific training round. At the start of each round, the FL server generates a unique nonce (challenge $ch$) and distributes it to participating clients. Each client must incorporate its challenge $ch_{i}$ into the attestation report, which the server verifies before accepting the corresponding model update. This mechanism ensures that attestations are valid only for their intended round, effectively mitigating replay attacks. Additionally, timestamps can be embedded in the report using trusted hardware timers in ARM TrustZone, further strengthening temporal freshness guarantees. In our system, control-flow $\mathcal{CF}_{i}$ and critical variable usage $\mathcal{CV}_{i}$ are securely stored by the trusted training recorder. At the end of each FL iteration, clients sign the measurements and model updates, along with the challenge, using their TEE signing key: $\sigma_{i}=\text{Sign}_{\text{TEE},sk_{i}}(H(\mathcal{CF}_{i},\mathcal{CV}_{i},\delta_{i}^{(t)},ch_{i})).$ The complete attestation report $(\sigma_{i},\mathcal{CF}_{i},\mathcal{CV}_{i},\delta_{i}^{(t)})$ is then transmitted securely to the task owner via a standard secure communication channel for verification.

Training Verification: Upon receiving the attestation report $(\sigma_{i},\mathcal{CF}_{i},\mathcal{CV}_{i},\delta_{i}^{(t)})$, the server first verifies its authenticity and integrity. It then validates both the control-flow integrity $\mathcal{CF}_{i}$ and critical variable usage $\mathcal{CV}_{i}$.

For control-flow verification, the server analyzes the execution trace and checks its consistency with the expected control-flow graph $\mathcal{CF}^{*}_{i}$ of the training process. The verifier iterates through the trace, validating branch conditions, jump/call targets, and return points. Instead of relying on hash-based methods, our design records explicit forward and return points, allowing the server to detect inconsistencies in call/return sequences indicative of control-flow hijacking. Verification halts immediately upon detecting a mismatch, minimizing computational overhead.

To verify critical variable usage $\mathcal{CV}_{i}$, the server ensures that static variables, such as hyperparameters and dataset configurations, remain read-only throughout training. Reported values are compared against expected usage $\mathcal{CV}^{*}_{i}$, and any unauthorized modification leads to rejection. For dynamic variables, including model weights, gradients, and loss values, verification checks whether updates follow valid data dependencies. For instance, model weights must be updated via optimizer steps, gradients must result from backpropagation, and loss values must derive from valid forward-pass computations.

If any anomaly is detected, such as inconsistent propagation sequences or unauthorized variable usage, the corresponding model updates are flagged as malicious and excluded from aggregation. Only updates that conform to both control-flow and data-flow constraints are accepted, preventing Byzantine clients from injecting manipulated results into the global model. The detailed protocol of Sentinel is illustrated in Fig. 3.

V Evaluation

V-A Experimental Setup

In our FL system, a parameter server coordinates 100 clients, each training a local model on private datasets initialized with global model weights. Datasets are partitioned as follows: (1) IID, where each client receives equal data covering all classes, and (2) non-IID, where each client receives equal data but only half of the classes randomly. Clients train locally for five epochs using Adam (learning rate 0.001) before submitting updates, with a total of 30 FL iterations. We evaluate on FMNIST [48] and CIFAR-10 [49]. Experiments are conducted on a server with an Intel Core i7 CPU, an NVIDIA GeForce RTX 3080 GPU, Ubuntu 22.04, and three Raspberry Pi V devices as simulated clients.

We compare our approach with FedAvg [2] and several defense baselines, including Krum [50], Coomed [51], TrimmedMean [51], Bulyan [15], and FLTrust [52]. To evaluate, we use control-flow hijacking and data-only attacks that compromise local training and alter model updates. Specifically, we implement Krum-Backdoor (targeted) [17] and Krum-Untargeted [16] attacks.

To test Sentinel, we design targeted and untargeted control-flow attacks, T-CF-Krum and UNT-CF-Krum, which redirect execution to a malicious optimizer, and data-only attacks, T-DO-Krum and UNT-DO-Krum, which replace benign updates with adversarial ones (Fig. 5).

We evaluate defenses using model accuracy (Acc) and attack success rate (ASR). For targeted attacks, ASR is the proportion of test inputs with a trigger misclassified as the target label. For untargeted attacks, where the goal is model degradation, Acc is used as the sole metric.

V-B Defense Effectiveness Results and Analysis

While some data-driven defenses can detect adversarial updates under IID conditions, they struggle in non-IID settings due to diverse client knowledge. Variations in model updates may result from legitimate drift rather than adversarial manipulation, causing poor detection and weak mitigation.

Results of targeted attacks (Tab. I) confirm this limitation. In IID settings, defenses such as Krum and Bulyan fail to reduce ASR, and their performance degrades further in non-IID cases, where ASR remains high. Since these aggregation rules rely on anomaly detection, they cannot distinguish adversarial updates from natural variations in heterogeneous clients. Similarly, under untargeted attacks (Tab. II), data-driven methods misclassify legitimate updates as malicious, reducing accuracy in non-IID scenarios and leaving models vulnerable. This highlights their reliance on fragile statistical heuristics.

In contrast, Sentinel integrates robust aggregation with a principled defense that separates adversarial behavior from natural heterogeneity. Our results show Sentinel nullifies targeted attacks (ASR = 0% in all cases) and achieves the highest accuracy under untargeted attacks, demonstrating clear advantages over conventional defenses.

V-C System Overhead Analysis

To evaluate the feasibility and overhead of integrating remote attestation into FL, we deploy Raspberry Pi V devices with Arm Cortex-A76 processors as FL clients to build a local training testbed (see Fig. 4). Each device simulates local training while running a parallel trusted training recorder. Code instrumentation in the source interpreter traces critical events, monitors stack frames, and inspects instructions during key workflows. Critical variables are verified before important steps and continuously monitored, with modifying instructions recorded. Each FL client trains on a small private dataset, reflecting real-world, privacy-sensitive on-device scenarios.

For consistency, models are trained with fixed batch sizes of 64, 128, and 256 for a single epoch, ensuring a controlled environment to measure attestation impact. All experiments are repeated 64 times, and average results are reported. We evaluate multiple ML tasks: CNNs and MobileNetV3 on FMNIST and CIFAR-10 for image classification, and an LSTM on IMDB for text classification. These cover workloads from lightweight CNNs to sequential models, providing a comprehensive view of attestation overhead across architectures. Metrics include runtime, memory usage, attestation report size, and verification latency (Tab. III).

Runtime Overhead: Remote attestation introduces moderate runtime increases, mainly from real-time measurement and trusted recording. More complex models with larger parameter sizes incur slightly higher overhead. Memory Overhead: Memory usage shows minimal growth, as the attestation mechanism relies on lightweight monitoring. Measurement Size and Verification Latency: Measurement size depends on model control-flow complexity and tracked variables, with deeper models producing larger records. Verification time, however, remains low across all tasks, avoiding bottlenecks in FL deployments.

VI Conclusion

In this work, we propose Sentinel, a remote attestation-based framework to enhance the security and transparency of FL training on remote devices. Unlike data-driven Byzantine-resilient approaches, Sentinel enforces system-level integrity checks to mitigate model poisoning and data poisoning attacks. By leveraging a TEE-based trusted training recorder, our design ensures that FL clients follow the expected training execution flow and do not manipulate critical variables. Experimental results demonstrate that Sentinel effectively detects adversarial manipulations while maintaining a low overhead in execution time and memory usage, making it practical for mission-critical devices for FL deployments.

Acknowledgment

This work was supported in part by the Office of Naval Research under grants N00014-24-1-2730, and the National Science Foundation under grants 2312447, 2247560, 2154929, and 2235232.