ExclaveFL: Verifiable Claims for Federated Learning using Exclaves
Listen
Radio episode about this paper
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.
Imperial College London · Azure Research · Microsoft Security Response Center
cs.CR, cs.DC, cs.LG
Submitted: 2024-12-13
Updated: 2026-11-14
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 82/100
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…
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
Summary
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. p. 0 We describe VerifiableFL, a system for training FL models that
establishes verifiable claims about trained FL models with the help
of fine-grained runtime attestation proofs. Since these runtime attestation proofs only require integrity protection, VerifiableFL
generates them using the new abstraction of exclaves. Using the graph, an
auditor verifies claims about the FL job (§5. 1 Constructing an exclave dataflow graph
The EDRs from all participants (collected by the EDR storage service) are used to construct a directed acyclic graph, which we refer
to as the exclave dataflow graph (EDG).Where the paper says it
Where the paper says it
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. p. 0 This makes it
challenging to provide verifiable claims about the trained FL model,
e. , related to the employed training data, any data sanitization,
or the correct training algorithm—a malicious data provider can
simply deviate from the correct training protocol without detection. In federated learning (FL) [29, 32, 45] scenario, the situation becomes worse, because training is performed by (potentially many)
data providers, rather than a single model provider. Claims about
models trained using FL thus require reputational trust in all data
providers, as well as the model provider. , when establishing an initial TLS
network connection [61]. Such static attestation proofs, however,
are hard to relate to claims about the final trained model: verifiable
claims depend on how the training process was carried out at
runtime but a static attestation proof only capture the state at the
start of the training process. If an attacker compromises the confidentiality of a TEE, they will have also compromised
the integrity of its attestation proofs. For example, a distributed FL
training system that relies on attested TLS connections between
data providers and the model provider [24] would be vulnerable to
an adversarial data provider who manages to leak the TLS session
key from their TEE using a side-channel.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
The Exclave Abstraction
VerifiableFL introduces exclaves as a hardware-based integrity-only execution environment that does not contain software-managed secrets and thus are immune to data leakage attacks. Unlike TEEs, exclaves do not offer confidentiality guarantees, meaning the only piece of data that must be kept secret from the adversary is a single attestation signing key. p. 4 Thus, the exclave offers integrity guarantees for its code
and data, even against privileged software running on the same
host. In contrast to TEEs, however, exclaves do not offer confidentiality
guarantees—the only piece of data that must be kept secret from the
adversary is a single attestation signing key. Exclaves support attestation through a hardware-based mechanism
(e. , a secure co-processor [67]) to measure code integrity and sign
an attestation statement at runtime that can include other runtime
data. VerifiableFL
uses exclaves to generate runtime attestation proofs of all executed
data transformations in the FL job, covering the transformations
performed by the data providers and the aggregations performed
by the model provider in each training round. Each attestation
proof, which we call an exclave data record (EDR), binds together
through hashes: (i) the data inputs to the transformation; (ii) the
code performing the transformation; and (iii) the resulting data
output of the transformation.Where the paper says it
Where the paper says it
Where the paper says it
Verifiable Claims and Auditing
VerifiableFL uses the EDRs to construct an end-to-end exclave dataflow graph (EDG) which provides a complete and integrity-protected representation of all data transformations that led to the final trained FL model. An auditor can use this EDG to verify claims about the FL job, such as correct training algorithm implementation or correct transmission of training data. p. 6 2 Checking verifiable claims
The constructed EDG is audited to verify claims about the trained FL
model. Next, we describe possible verifiable claims using examples
of specific training-time deviations and explain how an auditor
detects these deviations:
Claim 1: Correct FL training algorithm implementation. If the FL job includes a sanitization task, the correct execution of data sanitization is recorded by
the EDRs. Therefore, an auditor can compare the training tasks’s
input dataset commitment against the set of data commitments
produced by the sanitization task (Fig.Where the paper says it
Where the paper says it
Performance and Overhead Analysis
Experiments show that VerifiableFL can provide verifiable claims such that the FL model was trained with the correct algorithms and datasets with low overhead, introducing less than 12% overhead compared to an unprotected FL model training. The execution of the FL training job within exclaves and the generation of runtime attestation proofs reduces training throughput by less than 12% compared to a baseline without exclaves. p. 1 Since our exclave design requires minor changes to proprietary
TEE firmware, we implement a variant of our exclave design on
AMD SEV-SNP using its virtual TPM feature, thus offering similar
performance characteristics but slightly weaker security guarantees. Our experiments show that VerifiableFL can provide verifiable
claims such that the FL model was trained with the correct algorithms and datasets with low overhead: the execution of the FL
training job within exclaves and the generation of runtime attestation proofs reduces training throughput by less than 12% compared
to a baseline without exclaves. Across all models, the overhead
stays low. LeNet has a slightly higher overhead than other models,
because its small model requires little training time, which makes
it sensitive to the CVM overhead and VerifiableFL’s runtime and
I/O costs.Where the paper says it
Where the paper says it
Implementation Details
VerifiableFL executes each FL task within an exclave, which ensures execution integrity and produces EDRs for each executed data transformation. The system is compatible with existing FL frameworks like NVFlare by using Exclave Connectors that are implemented as NVFlare tasks. p. 8 Exclave Connectors are gRPC clients [28] that NVFlare uses to
execute FL tasks in exclaves. They are implemented as NVFlare
tasks, which makes them compatible with the NVFlare API. The Runtime Attestor records a hash of each data
item together with metadata that describes both the intended usage
(e. , input or output) and properties (e. The secure processor signs it together with a system measurement,
and returns the signed EDR. 3 Exclave emulation
To implement exclave attestation without relying on software secrets, we emulate the attestation path using a virtual Trusted Platform Module (vTPM) as the secure processor in AMD SEV-SNP.Where the paper says it
Where the paper says it
Where the paper says it
Conclusion
VerifiableFL introduces exclaves as a new abstraction for the execution of FL tasks with integrity only, which attest all performed data transformations at runtime. p. 0 Since these runtime attestation proofs only require integrity protection, VerifiableFL
generates them using the new abstraction of exclaves. Exclaves
are integrity-only execution environments, which do not contain
software-managed secrets and thus are immune to data leakage
attacks. This makes it
challenging to provide verifiable claims about the trained FL model,
e. , related to the employed training data, any data sanitization,
or the correct training algorithm—a malicious data provider can
simply deviate from the correct training protocol without detection. This makes it
challenging to provide verifiable claims about the trained FL model,
e. , related to the employed training data, any data sanitization,
or the correct training algorithm—a malicious data provider can
simply deviate from the correct training protocol without detection. Using the graph, an
auditor verifies claims about the FL job (§5. 1 Constructing an exclave dataflow graph
The EDRs from all participants (collected by the EDR storage service) are used to construct a directed acyclic graph, which we refer
to as the exclave dataflow graph (EDG). Using the graph, an
auditor verifies claims about the FL job (§5. 1 Constructing an exclave dataflow graph
The EDRs from all participants (collected by the EDR storage service) are used to construct a directed acyclic graph, which we refer
to as the exclave dataflow graph (EDG). The collected set of EDRs provides a trustworthy end-to-end record
of the training progress across the rounds of the FL computation. Therefore, an auditor can use the EDRs to discover violations of
specific claims about the trained FL model (see §5). The confidentiality guarantees of TEEs, however, have been shown
to be vulnerable to a wide range of attacks, such as side-channel
attacks. We describe VerifiableFL, a system for training FL models that
establishes verifiable claims about trained FL models with the help
of fine-grained runtime attestation proofs.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
REFERENCE
2412.10537
3 Exclaves
4 VerifiableFL Design
5 Auditing of Verifiable Claims
6.1 Overview
7.2 End-to-end throughput
7.3 Scalability
7.4 Performance breakdown, 7. p. 8 2); (ii) how does VerifiableFL scale with an
increased number of data providers and GPUs? 3); (iii) what is
the performance breakdown of VerifiableFL? Since our exclave design requires minor changes to proprietary
TEE firmware, we implement a variant of our exclave design on
AMD SEV-SNP using its virtual TPM feature, thus offering similar
performance characteristics but slightly weaker security guarantees. Our experiments show that VerifiableFL can provide verifiable
claims such that the FL model was trained with the correct algorithms and datasets with low overhead: the execution of the FL
training job within exclaves and the generation of runtime attestation proofs reduces training throughput by less than 12% compared
to a baseline without exclaves. 4); (iv) what overhead does VerifiableFL’s runtime attestation add? 5); (v) what
is the impact of secure storage on throughput and latency?Where the paper says it
Where the paper says it
Where the paper says it
--- Page 1 ---
VerifiableFL: Providing Verifiable Claims to Federated Learning using Exclaves
Jinnan Guo
Imperial College London
Kapil Vaswani
Azure Research
Andrew Paverd
Microsoft Security Response Center
Peter Pietzuch
Imperial College London
Abstract In federated learning (FL), data providers jointly train a machine learning model without sharing their training data. This makes it challenging to provide verifiable claims about the trained FL model, e. p. 0 VerifiableFL: Providing Verifiable Claims to Federated Learning
using Exclaves
Jinnan Guo
Imperial College London
Kapil Vaswani
Azure Research
Andrew Paverd
Microsoft Security Response Center
Peter Pietzuch
Imperial College London
Abstract
In federated learning (FL), data providers jointly train a machine
learning model without sharing their training data. This makes it
challenging to provide verifiable claims about the trained FL model,
e. This makes it
challenging to provide verifiable claims about the trained FL model,
e. , related to the employed training data, any data sanitization,
or the correct training algorithm—a malicious data provider can
simply deviate from the correct training protocol without detection. , related to the employed training data, any data sanitization,
or the correct training algorithm—a malicious data provider can
simply deviate from the correct training protocol without detection. While prior FL training systems have explored the use of trusted
execution environments (TEEs) to protect the training computation,
such approaches rely on the confidentiality and integrity of TEEs. While prior FL training systems have explored the use of trusted
execution environments (TEEs) to protect the training computation,
such approaches rely on the confidentiality and integrity of TEEs. The confidentiality guarantees of TEEs, however, have been shown
to be vulnerable to a wide range of attacks, such as side-channel
attacks. The confidentiality guarantees of TEEs, however, have been shown
to be vulnerable to a wide range of attacks, such as side-channel
attacks. We describe VerifiableFL, a system for training FL models that
establishes verifiable claims about trained FL models with the help
of fine-grained runtime attestation proofs. We describe VerifiableFL, a system for training FL models that
establishes verifiable claims about trained FL models with the help
of fine-grained runtime attestation proofs. Since these runtime attestation proofs only require integrity protection, VerifiableFL
generates them using the new abstraction of exclaves. Since these runtime attestation proofs only require integrity protection, VerifiableFL
generates them using the new abstraction of exclaves. Exclaves
are integrity-only execution environments, which do not contain
software-managed secrets and thus are immune to data leakage
attacks. Exclaves
are integrity-only execution environments, which do not contain
software-managed secrets and thus are immune to data leakage
attacks. VerifiableFL uses exclaves to attest individual data transformations during FL training without relying on confidentiality
guarantees. VerifiableFL uses exclaves to attest individual data transformations during FL training without relying on confidentiality
guarantees. The runtime attestation proofs then form an attested
dataflow graph of the entire FL model training computation. The runtime attestation proofs then form an attested
dataflow graph of the entire FL model training computation. The
graph is checked by an auditor to ensure that the trained FL model
satisfies its claims, such as the use of data sanitization by data
providers or correct aggregation by the model provider. The
graph is checked by an auditor to ensure that the trained FL model
satisfies its claims, such as the use of data sanitization by data
providers or correct aggregation by the model provider. VerifiableFL extends NVIDIA’s NVFlare FL framework to use exclaves. VerifiableFL extends NVIDIA’s NVFlare FL framework to use exclaves. Since exclaves require minor yet proprietary hardware changes,
we implement a variant of our design with similar performance
characteristics but slightly weaker security guarantees on existing
AMD SEV-SNP hardware. Since exclaves require minor yet proprietary hardware changes,
we implement a variant of our design with similar performance
characteristics but slightly weaker security guarantees on existing
AMD SEV-SNP hardware. We show that VerifiableFL introduces
less than 12% overhead compared to unprotected FL model training.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
1 Introduction As machine learning (ML) models continue to be used in new and diverse applications, there is increasing impetus towards providing information about how these models were trained. p. 0 We show that VerifiableFL introduces
less than 12% overhead compared to unprotected FL model training. 1 Introduction
As machine learning (ML) models continue to be used in new and
diverse applications, there is increasing impetus towards providing
information about how these models were trained. For example,
the EU AI Act [1], which came into force in August 2025, requires
providers of general-purpose ML models to provide “information
on the data used for training, [. ] including the type and provenance
of data and curation methodologies (e. ] including the type and provenance
of data and curation methodologies (e. cleaning, filtering etc. cleaning, filtering etc. ), the
number of data points, their scope and main characteristics; how the
data was obtained and selected as well as all other measures to detect
the unsuitability of data sources and methods to detect identifiable
biases, where applicable”. ), the
number of data points, their scope and main characteristics; how the
data was obtained and selected as well as all other measures to detect
the unsuitability of data sources and methods to detect identifiable
biases, where applicable”. In response to such requirements, datasheets for datasets [23]
describe the composition of training datasets, and model cards [49]
describe model training. In response to such requirements, datasheets for datasets [23]
describe the composition of training datasets, and model cards [49]
describe model training. Providers of open-source models, such as
the recently-trained Apertus [27], publish the code and datasets
used for training; providers of closed-source models also make
claims about their training process and datasets: e. Providers of open-source models, such as
the recently-trained Apertus [27], publish the code and datasets
used for training; providers of closed-source models also make
claims about their training process and datasets: e. , the model
card for OpenAI’s GPT-5 describes how the training data was preprocessed to remove personal information [53]. , the model
card for OpenAI’s GPT-5 describes how the training data was preprocessed to remove personal information [53]. Such claims may
be relevant to model providers as well as downstream users. For
example, model providers may want to demonstrate to regulators
that a model has not been trained on personal data or copyrighted
content; alternatively, they may want to show that the model has
been trained on certain data, such as under-represented languages,
as claimed by Apertus [27]. At present, such claims about model training and datasets are
made without proof and thus cannot be verified. At present, such claims about model training and datasets are
made without proof and thus cannot be verified. For closed-source
models, it is impossible to verify claims when interacting with the
model via an inference API. For closed-source
models, it is impossible to verify claims when interacting with the
model via an inference API. Even for open-source models, it is
generally infeasible to verify that a given model is indeed the result
of executing the provided training code on a specified dataset—
doing so would essentially require repeating the training process,
which would incur substantial costs, and the trained model may still
differ due to non-determinism. Even for open-source models, it is
generally infeasible to verify that a given model is indeed the result
of executing the provided training code on a specified dataset—
doing so would essentially require repeating the training process,
which would incur substantial costs, and the trained model may still
differ due to non-determinism. Today, model claims are therefore
accepted based on the reputational trust in model providers. Today, model claims are therefore
accepted based on the reputational trust in model providers. In federated learning (FL) [29, 32, 45] scenario, the situation becomes worse, because training is performed by (potentially many)
data providers, rather than a single model provider. In federated learning (FL) [29, 32, 45] scenario, the situation becomes worse, because training is performed by (potentially many)
data providers, rather than a single model provider. Claims about
models trained using FL thus require reputational trust in all data
providers, as well as the model provider.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
--- Page 2 ---
Conference’17, July 2017, Washington, DC, USA Jinnan Guo, Kapil Vaswani, Andrew Paverd, and Peter Pietzuch
We argue that TEEs are the wrong abstraction to create verifiable claims about FL model training for two reasons. (1) Existing solutions focus on static attestation proofs. p. 1 Indeed, prior designs of FL training systems have
used TEEs to offer claims about trained ML models by leveraging
such attestation proofs [24, 58, 61]. We argue, however, that TEEs are the wrong abstraction to create
verifiable claims about FL model training for two reasons:
(1) Existing solutions focus on static attestation proofs. We argue, however, that TEEs are the wrong abstraction to create
verifiable claims about FL model training for two reasons:
(1) Existing solutions focus on static attestation proofs. In
FL training systems with TEEs [24, 58, 61], TEEs produce memory
measurements at deployment time to provide a static attestation
proof that establishes that the TEE runs the expected FL system
and training code. For example, if a data provider skips
data sanitization in a given training round to poison the model, this
would be difficult to discern from a single static attestation proof
at deployment time. (2) Existing attestation relies on confidentiality. (2) Existing attestation relies on confidentiality. As we show,
TEE implementations rely on confidentiality to provide unforgeable
attestation proofs.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
--- Page 3 ---
VerifiableFL: Providing Verifiable Claims to Federated Learning using Exclaves Conference’17, July 2017, Washington, DC, USA Jinnan Guo, Kapil Vaswani, Andrew Paverd, and Peter Pietzuch
We observe that FL training should instead rely on a set of runtime attestation proofs about data transformations performed during FL training. The fact that particular data transformations have been carried out faithfully can then be related to claims about the final trained FL model. p. 1 We observe that FL training should instead rely on a set of
runtime attestation proofs about data transformations performed
during FL training. The fact that particular data transformations,
such as data sanitization [54], local training [32], poisoning mitigations [21, 31, 79] and model aggregation [79], have been carried out
faithfully can then be related to claims about the final trained FL
model. The fact that particular data transformations,
such as data sanitization [54], local training [32], poisoning mitigations [21, 31, 79] and model aggregation [79], have been carried out
faithfully can then be related to claims about the final trained FL
model. Importantly, these runtime attestation proofs only require
guarantees about the integrity of data transformations and not their
confidentiality.Where the paper says it
Where the paper says it
To realise the above approach, our work makes the following two contributions. p. 1 Therefore, our approach can avoid the more challenging security model of TEEs, which must protect against both
confidentiality and integrity attacks. To realise the above approach, our work makes the following
two contributions:
(1) We describe a new abstraction called an exclave, which is a
hardware-based integrity-only execution environment. Therefore, our approach can avoid the more challenging security model of TEEs, which must protect against both
confidentiality and integrity attacks. To realise the above approach, our work makes the following
two contributions:
(1) We describe a new abstraction called an exclave, which is a
hardware-based integrity-only execution environment. Exclaves support attestation through a hardware-based mechanism
(e. , a secure co-processor [67]) to measure code integrity and sign
an attestation statement at runtime that can include other runtime
data. We show how exclaves can
be realized through minor modifications to existing hardware-based
TEE implementations. (2) Using exclaves, we describe the design and implementation
of VerifiableFL, a system for executing FL training jobs that
provides verifiable claims about trained FL models. (2) Using exclaves, we describe the design and implementation
of VerifiableFL, a system for executing FL training jobs that
provides verifiable claims about trained FL models. VerifiableFL
uses exclaves to generate runtime attestation proofs of all executed
data transformations in the FL job, covering the transformations
performed by the data providers and the aggregations performed
by the model provider in each training round.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
--- Page 4 ---
Conference’17, July 2017, Washington, DC, USA Jinnan Guo, Kapil Vaswani, Andrew Paverd, and Peter Pietzuch
We create a prototype implementation of VerifiableFL that extends the existing FL framework NVFlare [64] to execute individual FL tasks that carry out data transformations in an FL training job inside exclaves. Since our exclave design requires minor changes to proprietary TEE firmware, we implement a variant of our design on AMD SEV-SNP using its virtual TPM feature, thus offering similar performance characteristics but slightly weaker security guarantees. p. 1 VerifiableFL achieves this without
requiring changes to the FL jobs or the framework implementation. Since our exclave design requires minor changes to proprietary
TEE firmware, we implement a variant of our exclave design on
AMD SEV-SNP using its virtual TPM feature, thus offering similar
performance characteristics but slightly weaker security guarantees. Since our exclave design requires minor changes to proprietary
TEE firmware, we implement a variant of our exclave design on
AMD SEV-SNP using its virtual TPM feature, thus offering similar
performance characteristics but slightly weaker security guarantees. Our experiments show that VerifiableFL can provide verifiable
claims such that the FL model was trained with the correct algorithms and datasets with low overhead: the execution of the FL
training job within exclaves and the generation of runtime attestation proofs reduces training throughput by less than 12% compared
to a baseline without exclaves.Where the paper says it
Where the paper says it
--- Page 5 ---
Conference’17, July 2017, Washington, DC, USA Jinnan Guo, Kapil Vaswani, Andrew Paverd, and Peter Pietzuch
In our threat model we assume that any participant in the FL training job (i.e., any data provider or the centralized model provider), or any set of colluding participants could be adversarial. p. 3 5 Threat model and security goals
In our threat model, we assume that any participant in the FL training job (i. , any data provider or the centralized model provider),
or any set of colluding participants, could be adversarial. Adversary goal. The adversary aims to deviate from the predefined
FL training protocol, in a way that modifies or influences the final
FL model and for this deviation to remain undetectable by other
participants and/or third-party auditors. Security goals. VerifiableFL aims to ensure that the aforementioned adversary is unable to deviate from the predefined FL training protocol, in a way that modifies or influences the final model,
4Where the paper says it
Where the paper says it
Where the paper says it
--- Page 6 ---
Conference’17, July 2017, Washington, DC, USA Jinnan Guo, Kapil Vaswani, Andrew Paverd, and Peter Pietzuch
The adversary goal encompasses many specific attacks that different participants could attempt. For example an adversarial data provider may perform fewer rounds of training to reduce resource costs; or skip a pre-processing step that would otherwise filter out specific data. p. 3 This broad adversary goal encompasses many specific attacks
that different participants could attempt: e. , an adversarial data
provider may perform fewer rounds of training to reduce resource
costs; or skip a pre-processing step that would otherwise filter out
specific data; or change their dataset during training to bias the final
model.Where the paper says it
--- Page 7 ---
Conference’17, July 2017, Washington, DC, USA Jinnan Guo, Kapil Vaswani, Andrew Paverd, and Peter Pietzuch
We define a verifiable claim to be any statement about the FL training process that could have been made by a (hypothetical) trusted omniscient observer with full visibility of the training process. Claims could include statements about the executed code for training and aggregation, the number of participants and rounds of training, or any other runtime property of the FL job. p. 4 Specifically, we define a verifiable claim to be any statement
about the FL training process that could have been made by a (hypothetical) trusted omniscient observer with full visibility of the
training process. Claims could include statements about the executed code for training and aggregation, the number of participants
and rounds of training, or any other runtime property of the FL job.Where the paper says it
--- Page 8 ---
Conference’17, July 2017, Washington, DC, USA Jinnan Guo, Kapil Vaswani, Andrew Paverd, and Peter Pietzuch
--- Page 9 ---
Conference’17, July 2017, Washington, DC, USA Jinnan Guo, Kapil Vaswani, Andrew Paverd, and Peter Pietzuch
--- Page 10 ---
Conference’17, July 2017, Washington, DC, USA Jinnan Guo, Kapil Vaswani, Andrew Paverd, and Peter Pietzuch
--- Page 11 ---
Conference’17, July 2017, Washington, DC, USA Jinnan Guo, Kapil Vaswani, Andrew Paverd, and Peter Pietzuch
--- Page 12 ---
Conference’17, July 2017, Washington, DC, USA Jinnan Guo, Kapil Vaswani, Andrew Paverd, and Peter Pietzuch
--- Page 13 ---
Conference’17, July 2017, Washington, DC, USA Jinnan Guo, Kapil Vaswani, Andrew Paverd, and Peter Pietzuch
We describe VerifiableFL as a new system for executing FL jobs while enabling an auditor to verify claims about the final trained FL model. VerifiableFL introduces exclaves as a new abstraction for the execution of FL tasks with integrity only, which attest all performed data transformations at runtime. Since executed FL tasks are attested through exclave data records (EDRs), it becomes impossible for participants to deviate from the correct FL training protocol, thus violating model claims, without detection. Exclaves produce EDRs which can be combined to create an exclave dataflow graph (EDG) that spans the entire FL job. An auditor uses the EDG to verify end-to-end claims about the FL job
--- Page 14 ---
Conference’17, July 2017, Washington, DC, USA Jinnan Guo, Kapil Vaswani, Andrew Paverd, and Peter Pietzuch
We show that VerifiableFL can be integrated with a state-of-the-art FL framework to detect a wide range of deviations with low runtime overhead.
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
- Verifiable Claims via Exclaves
This system establishes verifiable claims about trained FL models by using exclaves to generate runtime attestation proofs (EDRs) of all executed data transformations. This allows an auditor to check claims such as the use of data sanitization by data providers or correct aggregation by the model provider.
- Runtime Attestation for Data Transformations
Exclaves are integrity-only execution environments that do not rely on confidentiality, allowing them to attest individual data transformations during FL training without relying on confidentiality guarantees. Exclave Data Records (EDRs) bind together through hashes: (i) the data inputs to the transformation; (ii) the code performing the transformation; and (iii) the resulting data output of the transformation.
- End-to-End Verifiable Dataflow Graph Auditing
VerifiableFL constructs an exclave dataflow graph (EDG) from all EDRs to establish a complete and integrityprotected representation of all data transformations that led to the final trained FL model.
An auditor uses this EDG to detect deviations, such as Incorrect orchestration,
where the shape of the resulting EDG would differ from that of the expected EDG.
- Detection of Protocol Deviations
The system can detect deviations from training protocols by checking each vertex in the EDG against an allowed list of acceptable code measurements for tasks in the FL job.
For example, it can identify if a data provider skips a given pre-processing step that removes personal information from a dataset
or if they modify their training code.
- Verification of Data Integrity
The system ensures the integrity of training datasets by using Linux dm-verity to package datasets with a Merkle tree, and checks these commitments against the Merkle tree when accessing data inside an exclave. This allows detection of Modified dataset
attacks where a malicious provider could add, remove, or modify its dataset after training has commenced.
- Verification of Sanitization Tasks
VerifiableFL can verify that appropriate dataset sanitization has occurred by comparing the training tasks’s input dataset commitment against the set of data commitments produced by the sanitization task.
This allows an auditor to check if a provider used a non-compliant dataset, e.g., with harmful content or personal information, without sanitization.
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.
Sources
- 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
Related papers
- From Strategy Search to Policy Learning: MCTS-Guided Adversarial Co-Evolution for LLM Safety Alignment
- Privacy Leakage from Recurrent State in LLM Inference
- Incrementally Verifiable Oracle Aided Computation
- Privilege and confidentiality in generative AI workflows
- BadMoE: Backdooring Mixture-of-Experts LLMs via Routing-Aware Triggers and Task-Underutilized Experts
- CoVault: Secure, Scalable Analytics of Personal Data