cs.CRDec 13, 2024

ExclaveFL: Verifiable Claims for Federated Learning using Exclaves

Authors: Jinnan Guo, Kapil Vaswani, Andrew Paverd, Peter Pietzuch

Organizations: Imperial College London · Azure Research · Microsoft Security Response Center

Abstract

In federated learning (FL), data providers jointly train a machine learning model without sharing training data. This makes it challenging to provide verifiable claims about the trained model, e.g., related to the employed training data, data sanitization, or training algorithm---a malicious data provider can simply deviate from the correct training protocol without detection. Prior FL training systems have used trusted execution environments (TEEs) to protect the training computation, relying on the confidentiality and integrity of TEEs. TEE confidentiality, however, has been shown to be vulnerable to various attacks, e.g., via side channels. We describe ExclaveFL, a system for training FL models that establishes verifiable claims about models through fine-grained runtime attestation proofs. Since such proofs only require integrity, ExclaveFL generates them using exclaves, which are integrity-only execution environments without software-managed secrets, making them immune to data leakage attacks. ExclaveFL uses exclaves to attest data transformations during FL training, and the runtime attestation proofs then form an attested dataflow graph of the entire training computation. The graph is checked by an auditor to ensure that the trained model satisfies claims, e.g., about the use of data sanitization by data providers or aggregation by the model provider. Since exclaves require minor yet proprietary firmware changes, we evaluate a variant with similar performance but slightly weaker security guarantees on existing AMD SEV-SNP hardware. We show that ExclaveFL introduces less than 12% overhead compared to unprotected FL model training.

Figures & tables

Explore similar work

Jul 7, 2026

PRoVeFL: Private Robust and Verifiable Aggregation in Federated Learning

Federated Learning (FL) enables multiple clients to collaboratively train machine learning models while retaining data locality, thereby enhancing user privacy. However, traditional FL frameworks rely on a centralized aggregation server and assume honest-but-curious clients, making them susceptible to both server-side inference and client-side poisoning attacks. Although recent work has explored secure and Byzantine-resilient FL protocols, they face a fundamental trade-off among privacy, integrity, and verifiability, and incur substantial computational and communication overhead due to the heavy use of cryptographic primitives. In this work, we propose PRoVeFL-a novel, modular FL framework that is Privacy-preserving, Byzantine-Robust, and ensures Verifiable aggregation. PRoVeFL employs multiple servers leveraging multi-key fully homomorphic encryption. Each client encrypts its local model updates and distributes encrypted shares to all servers. This design enables a hybrid computation model in which ciphertext operations are carefully offloaded to the plaintext domain under strict privacy constraints to efficiently evaluate complex statistical aggregation rules. PRoVeFL is compatible with a wide range of state-of-the-art Byzantine-robust aggregation algorithms (e.g., Krum, Trimmed Mean, FLTrust, norm clipping, MESAS, and more) and further enhances them with verifiability mechanisms that require minimal trust in at least one honest server. We evaluate it across different settings and demonstrate its scalability with varying numbers of parameters and participants. PRoVeFL improves runtime over the prior works, Prio and ELSA, based on distributed trust with comparable security guarantees, up to 100x and 10x, respectively.
Oct 30, 2026

AuditFL: A Contract-Backed Clearing Layer for Open Federated Learning

Federated learning (FL) keeps raw data local, but most deployments still rely on a trusted coordinator for client admission, checkpoint distribution, update collection, aggregation, and rewards. This paper presents AuditFL, a contract-backed clearing layer for auditable FL in open settings. AuditFL keeps training and aggregation off chain, stores model artifacts in an assumed reliable off-chain artifact store, and records only content identifiers and economic state on chain. Clients reserve update tickets with deposits, publish update identifiers, and later claim refunds or rewards; the task coordinator publishes global checkpoints and finalizes rounds through deterministic settlement rules. The design does not remove the aggregator, but makes its on-chain round decisions attributable, replayable, auditable, and economically constrained. We implement AuditFL as both a deterministic state-machine prototype and a Solidity contract on a local Ethereum-compatible Anvil chain. On full MNIST with Dirichlet non-IID splits, 12 rounds, and up to 200 clients, AuditFL preserves the Plain FL learning trajectory while its overhead follows closed-form control-plane models. At 200 clients, the contract run issues 5,026 transactions, stores 2,413 off-chain artifacts (144.9 MiB), and consumes 829.7M EVM gas, dominated by per-client reserve and publish calls. Controlled dropout, invalid-update, and artifact-unavailability stress tests reduce inclusion nearly linearly but still finalize rounds, with final-accuracy changes remaining within a few tenths of an accuracy percentage point even under high injected failure rates.
Sep 29, 2026

OPFL: Optimistic Verification of Federated Learning via Empirical Boundary

Federated learning enables multiple clients to collaboratively train models without sharing their private data. However, the lack of visibility into local training makes it difficult to verify whether clients follow the prescribed training procedure or submit malicious updates, such as model poisoning. A natural approach is to replay client training for verification. However, privacy-preserving replay produces numerical results that cannot be directly matched with local client execution because the two run in different environments. We present OPFL, an optimistic verification framework for privacy-preserving federated learning. To protect data privacy, OPFL performs replay inside secure multi-party computation (MPC). Although gradients computed on MPC and local GPUs are not bitwise identical, we observe that their absolute differences are stable and bounded. OPFL therefore calibrates an empirical boundary offline and uses it to distinguish benign numerical deviations from malicious manipulation. To reduce the cost of expensive MPC replay, OPFL adopts optimistic verification by post auditing only sampled training steps. Experiments on LeNet, BERT, and Qwen show that the boundary generalizes across datasets, input lengths, and GPUs, while achieving 00% ASR against model poisoning and PGD-based attacks. On a LeNet workload, at p=0.01p=0.01, OPFL is approximately 98.6×98.6\times faster than full MPC-based FL and 625.5×625.5\times faster than ZK-based approach.