ExclaveFL: Verifiable Claims for Federated Learning using Exclaves
summary
The gist
VerifiableFL describes VerifiableFL, a system for training FL models that establishes verifiable claims about trained FL models with the help of fine-grained runtime attestation proofs The system…
In short
VerifiableFL trains Federated Learning (FL) models by using 'exclaves,' which are hardware environments ensuring integrity-only execution. These exclaves generate runtime attestation proofs called Exclave Data Records (EDRs) for every data transformation. An auditor uses these EDRs to build an End-to-End Dataflow Graph (EDG) to verify claims about the training process, such as correct data sanitization or algorithm implementation.
Key concepts
- Exclaves
- These are hardware environments designed for integrity-only execution. They do not rely on confidentiality and are immune to data leakage attacks, making them ideal for attesting data transformations during FL training without needing software-managed secrets.
- Exclave Data Record (EDR)
- An EDR is a runtime attestation proof generated by an exclave that binds together three elements: the input data, the code performing the transformation, and the resulting output. This record proves exactly what happened during a specific step of the FL training process.
- Exclave Dataflow Graph (EDG)
- The EDG is a complete map constructed from all EDRs generated throughout an entire FL job. Auditors use this graph to verify end-to-end claims, ensuring that every transformation, from data input to final model output, followed the expected protocol.
- Runtime Attestation
- This mechanism allows exclaves to measure code integrity and sign statements at runtime that include other data. Unlike static proofs, these are generated during the actual training process, providing verifiable claims about how data was transformed in real-time.
Terminology used across episodes
This episode discusses
- ExclaveFL: Verifiable Claims for Federated Learning using Exclaves · Paper Radio
- When the Curious Abandon Honesty: Federated Learning Is Not Private
- Intel TDX Demystified: A Top-Down Approach
- Datasheets for Datasets
- Federated Learning for Mobile Keyboard Prediction
- Apertus: Democratizing Open and Compliant LLMs for Global Language Environments
- Understanding the Sparse Vector Technique for Differential Privacy
- Pointer Sentinel Mixture Models
- Granite Guardian
- Why and How zk-SNARK Works
- SecFL: Confidential Federated Learning using TEEs
- Federated Learning for Emoji Prediction in a Mobile Keyboard
- OpenFL: An open-source framework for Federated Learning
- CrowdGuard: Federated Backdoor Detection in Federated Learning
- NVIDIA FLARE: Federated Learning from Simulation to Real-World
- DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter
- Very Deep Convolutional Networks for Large-Scale Image Recognition
The paper
ExclaveFL: Verifiable Claims for Federated Learning using Exclaves · Read on arXiv
Imperial College London · Azure Research · Microsoft Security Response Center
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.
Transcript
Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.
Nadia: I'm Nadia.
Elias: And I'm Elias, here with Priya.
Nadia: We're looking at the paper: "ExclaveFL: Verifiable Claims for Federated Learning using Exclaves".
Elias: Here's the gist of the paper. VerifiableFL describes VerifiableFL, a system for training FL models that establishes verifiable claims about trained FL models with the help of fine-grained runtime attestation proofs The system introduces exclaves as a new abstraction for the execution of FL tasks with integrity only, which attest all performed data transformations at runtime.
Nadia: This approach allows an auditor to verify end-to-end claims about the FL job by constructing an exclave dataflow graph (EDG) from these proofs.
Elias: The Problem in Federated Learning In federated learning (FL), it is challenging to provide verifiable claims about the trained FL model, e.g., related to the employed training data, any data sanitization, or the correct training algorithm.
Nadia: Claims about models trained using FL thus require reputational trust in all participants, as well as the model provider.
Title and authors: Nadia: So, we're looking at this paper, ExclaveFL: Verifiable Claims for Federated Learning using Exclaves, and it tackles that big problem where you can't really trust who trained a machine learning model in federated learning because everyone keeps their data private.
Elias: Exactly. The title says they are using exclaves to establish verifiable claims about the trained models, which means they want to prove things like whether a specific data provider actually used the right training data or performed a certain sanitization step.
Priya: But first, we need to understand what the paper is proposing because existing solutions with trusted execution environments, or TEEs, have their own problems with confidentiality and side-channel attacks.
Nadia: Right. So what's this new idea they are pushing instead of relying on those TEEs for verification?
Elias: They argue that instead of static proofs—which only check the system state at the very beginning of training—they should use runtime attestation proofs about every single data transformation happening during the training rounds.
Priya: That sounds like it shifts our focus from just checking the final model to auditing the entire process step by step, which is a big shift for privacy research.
Nadia: It does, and they introduce this concept called exclaves, which they describe as a hardware-based execution environment that only guarantees integrity, not confidentiality.
Elias: That's important because it means these environments don't rely on hiding secrets from an adversary through software; instead, they use hardware mechanisms to measure code integrity and sign statements at runtime about the data transformations being done.
Priya: So if they don't guarantee confidentiality, what does that mean for the data itself? Does it still mean we can trust the inputs or outputs of those transformations?
Nadia: Well, they say that because these exclaves are integrity-only, any deviation from the correct training protocol becomes impossible to hide without detection because every transformation generates an exclave data record.
Elias: Those data records are what they call exclave data records, or EDRs; these aren't just static measurements; they bind together the input data to the code performing the transformation and the resulting output of that specific step.
Title and authors: Priya: So, how does an auditor actually use all these individual EDRs to get a complete picture of what happened during all those training rounds?
Nadia: They construct something called an exclave dataflow graph, or EDG; this graph represents the entire sequence of data transformations that led to the final trained model.
Elias: That EDG is what gives the auditor a complete and integrity-protected representation of every single step in the FL job, allowing them to check claims about things like correct training algorithm implementation.
Priya: And they mention specific checks, like comparing the input dataset commitment against the set of data commitments produced by a sanitization task; that seems really concrete.
Nadia: It is concrete because they show you can use this EDG to verify if a data provider actually performed a specific sanitization step or if the model provider correctly aggregated those updates.
Elias: The paper also discusses how they've extended an existing FL framework, NVFlare, by using these exclaves, noting that they implemented a variant on AMD SEV-SNP hardware to show similar performance characteristics.
Priya: What about the performance? Because adding this level of runtime checking sounds like it could introduce a lot of overhead during the actual training process.
Nadia: They show that the overall overhead is quite low; it's less than twelve percent compared to an unprotected FL model training scenario, which is pretty good for real-world deployment.
Elias: The execution inside these exclaves and the proof generation itself reduce the total training throughput by less than twelve percent when you compare it to a baseline without those exclaves.
Priya: And for the auditing part, how much time does that graph construction and verification take? We need to know if that's going to be a bottleneck for anyone checking these claims later on.
Nadia: The auditing process itself is shown to have negligible overhead, taking only nineteen seconds when they scale up to one hundred clients and one thousand rounds.
Elias: So, this system allows you to detect deviations from the training protocol with low runtime overhead, which is a significant practical advantage over what we've seen before.
Title and authors: Priya: It seems like the paper successfully addresses that initial hurdle of relating data transformations to verifiable claims through this new structure of EDRs and EDGs.
Nadia: Exactly; they make it impossible for participants to deviate from the correct FL training protocol without detection by checking each vertex in that graph against an allowed list of acceptable code measurements.
Elias: That means if a data provider skips a pre-processing step or modifies their training code, the resulting EDG won't match the expected one, and that deviation will be flagged.
Priya: It’s interesting how they use this integrity focus instead of confidentiality to build this verification layer for federated learning claims.
Nadia: It changes how we think about proving model provenance; instead of trusting a black box TEE, you're building a verifiable chain of integrity records throughout the entire training lifecycle.
Elias: If you look at the title ExclaveFL: Verifiable Claims for Federated Learning using Exclaves, it really tells you that the core contribution is this mechanism for integrity-only execution environments that generate runtime proof data.
Priya: So, to wrap up on what this paper delivers: they provide a way to verify end-to-end claims about FL jobs by combining individual runtime proofs into one comprehensive graph.
Nadia: That's right; it provides an exclave dataflow graph that spans the entire job, which allows an auditor to verify things like correct aggregation or data sanitization steps.
Elias: It shows that even with these runtime attestation proofs, you can maintain a low overhead, keeping the performance penalty under twelve percent compared to standard training.
Priya: So for anyone interested in how we actually trust the data used in federated learning, this system provides a framework where integrity checks are tied directly to verifiable claims about the final model.
Nadia: That's ExclaveFL for you; it introduces exclaves as an abstraction that attests all performed data transformations at runtime, making protocol deviation detectable and verifiable.
Elias: It’s a solid piece of work because it moves verification away from static checks and toward continuous, fine-grained runtime integrity measurement during the training process itself.
The paper's summary: Nadia: So, to recap this paper, they’re proposing using these hardware execution environments called exclaves to get verifiable claims about federated learning models by tracking every single data transformation step at runtime.
Elias: Exactly. The core idea is that instead of relying on static checks or hiding secrets through software confidentiality, they use these integrity-only environments to generate specific data records for every action taken during training.
Nadia: And those individual records, they bundle up into this whole flow graph thing called the exclave dataflow graph, or EDG.
Elias: That EDG lets an auditor trace the entire history of the model's creation, allowing them to check claims like whether a specific sanitization step actually happened or if the correct aggregation was performed.
Nadia: It sounds like they’ve built this system so that it becomes impossible for anyone in the training process—the data provider or even the central model provider—to deviate from the agreed-upon protocol without leaving a detectable trace in that graph.
Elias: That’s because every step, every transformation, produces a record that gets hashed together to form this complete picture of what happened.
Nadia: But here’s where I want to push back a little bit—they mention they use hardware like AMD SEV-SNP for their prototype on existing setups.
Elias: Right. They acknowledge that this specific implementation uses features like the virtual trusted platform module in AMD SEV-SNP, which means it has slightly weaker security guarantees than a fully custom exclave design might have.
Nadia: So, what does that mean practically? Does it mean we can trust the claims as much as if they were running on some custom hardware we designed ourselves?
Elias: It means for now, the performance is good, under twelve percent overhead compared to just training without these exclaves, and they’ve shown that even with this setup, you can verify things with very low runtime costs.
Nadia: That’s a big deal because proving something in real-world FL scenarios usually introduces huge latency.
Elias: Exactly. And the auditing part itself is fast; they said verifying all those data records and building the whole graph takes only nineteen seconds when they scale up to one hundred clients and one thousand training rounds.
Nadia: So, what this means for someone who just listens to the show is that we’re moving toward a future where you can actually audit the entire training process of a federated model, not just check the final output.
Elias: It shifts the trust model away from relying on reputation and toward verifiable integrity checks built directly into the execution layer itself.
Nadia: But we still need to look at what they didn't cover—specifically, how robust this works against those side-channel attacks they said TEEs are vulnerable to.
Elias: That’s a fair point; it’s an integrity-only approach, not a confidentiality one, so the authors aren't promising absolute secrecy for the data itself.
Nadia: So while we gain verifiable claims about *what* happened during training, we still have to worry about what happens to the sensitive raw data inside those exclaves.
Elias: Right. That’s exactly where you need to keep an eye on it because that distinction between integrity and confidentiality is what defines this whole approach.
Nadia: We need to see how well this system holds up when a malicious actor tries to manipulate the training steps in ways that might not immediately break the graph structure, but subtly change the final model’s behavior.
The paper's improvements: Tom: So, we’re looking at how the authors are suggesting ways to make this work even better than what they just described in this paper.
Nadia: They focus on extending the system so that it can catch more specific kinds of protocol deviations during training.
Elias: Right. Instead of just checking if a piece of code is correct, they want to build a system that checks against an allowed list for every single task in the federated job.
Nadia: That means you could detect if a data provider skips a specific pre-processing step that’s supposed to filter out personal information or if they actually modify their training code.
Elias: They are building this by checking each vertex in that exclave dataflow graph against those allowed measurements for every task in the job.
Nadia: And they also talk about verifying the integrity of the raw datasets themselves, which is a big step because we know data modification attacks are a real threat.
Elias: They use something called linux dm-verity to package those datasets with a Merkle tree, and then they check those commitments against that Merkle tree when accessing data inside an exclave.
Nadia: So they can catch if a malicious provider adds, removes, or modifies its dataset after the training has already started.
Elias: That’s how you verify data integrity at the storage level, so it’s not just about what happens during computation but also ensuring the starting material was correct.
Nadia: It seems like they are really tying together all these components—the runtime proofs, the flow graph, and the dataset commitments—into one single verifiable system.
Elias: That integration is what makes it powerful; it moves beyond just proving a single step is okay to proving the entire sequence of data transformations was correct.
Nadia: It really shows how this approach can provide verifiable claims about the final model without needing to trust every single participant in a federated setup.
Elias: And they’re looking at future work where they might try to make this more flexible, perhaps moving away from the specific hardware like AMD SEV-SNP toward something more general or adaptable for different platforms.
Nadia: That would be interesting because right now, the prototype is tied to that specific hardware implementation.
Elias: Yeah, and they'll need to figure out how to generalize that proof generation mechanism so it can work across a wider variety of execution environments without needing custom firmware changes every time.
Conclusion: Nadia: So, to wrap up, VerifiableFL introduces exclaves as an integrity-only way to attest all data transformations during federated learning at runtime, building an exclave dataflow graph for auditors to verify claims end-to-end.
Elias: Right. The big implication is that it makes it possible to establish verifiable claims about trained federated models by using fine-grained runtime attestation proofs instead of relying on static checks or confidentiality guarantees from TEEs.
Nadia: It means participants can't just claim they followed the training protocol if they deviate, because that deviation leaves a trace in the graph that an auditor can see.
Elias: Exactly. The system detects protocol deviations by checking each step in that graph against an allowed list of measurements, which is how you catch things like skipped sanitization steps or modified training code.
Priya: I just want to emphasize that while the system proves *what* happened during the process, we still need to be very careful about what the raw data inside those exclaves actually shows before we trust any claimed result.
Nadia: That’s fair, Priya, and it’s where the integrity-only aspect is really important—it verifies the transformation chain, but doesn't guarantee that the data itself wasn't compromised in a way that bypasses that specific attestation method.
Elias: I agree. The authors are pretty clear about this limitation; they aren't making any promises about data confidentiality, which is a key trade-off for getting this level of integrity verification.
Nadia: So, the numbers show it works with low overhead, under twelve percent compared to unprotected training and a quick nineteen seconds for auditing when scaling up to one hundred clients and one thousand rounds.
Elias: It’s an engineering win because it shows that you can actually add this layer of verification without crippling the training throughput or making the auditing process too slow.
Priya: From my side, I see this as a strong tool for accountability in FL, giving us a measurable way to check if data providers are doing what they promised regarding privacy and curation methodologies.
Nadia: So, VerifiableFL provides that complete picture of the training job’s history through its exclave dataflow graph.
Elias: It’s a solid system because it moves verification from checking the final state to verifying every single transformation in between, which is a major step forward for proving model provenance.
Priya: I think this framework gives us a much better way to audit the quality of training data used in these complex machine learning scenarios.
Nadia: That’s it for this deep dive into VerifiableFL: the system that uses exclaves to establish verifiable claims about federated learning using fine-grained runtime attestation proofs.
Elias: We’ll be looking at how this integrity focus compares to other privacy tools next week, so keep an eye on that.
More episodes
- 2608.27496-ROPE: Routed Origin Policy Enforcement against Indirect Prompt Injection
- Daily Summary for 2026-11-19
- 2607.07085-Is Randomness Necessary for Adaptive Data Analysis?
- The day in conversation for 2026-11-19
- Daily Summary for 2026-11-19
- 2609.10601-Threshold Choice, Not Sample Size, Bounds Trustless Verification of Nondeterministic Compound AI Workflows
- 2610.38786-Adversarial Process Disturbances at a Deployable Alarm Budget: Detector Evaluation on a Simulator and a Real Plant
- 2511.08660-Binary and Multiclass Cyberattack Classification on GeNIS Dataset
- 2604.27302-Static Attribution of Android Residential Proxy Malware Using Graph Kernels
- Daily Summary for 2026-11-18