ExclaveFL: Verifiable Claims for Federated Learning using Exclaves

arXiv:2412.10537 · cs.CR, cs.DC, cs.LG · Submitted 2024-12-13 · Read on arXiv

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

Where the paper says it

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.

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. p. 6
Where the paper says it

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 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

Where the paper says it

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.

Claims about models trained using FL thus require reputational trust in all participants, as well as the model provider. p. 0
Where the paper says it

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.

Existing solutions focus on static attestation proofs which are hard to relate to claims about the final trained model because they only capture the state at the start of the training process. p. 1
Where the paper says it

, 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.

Furthermore, existing attestation relies on confidentiality, which is vulnerable to side-channel attacks. p. 1
Where the paper says it

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.

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

Where the paper says it

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.

These exclaves support attestation through a hardware-based mechanism to measure code integrity and sign an attestation statement at runtime that can include other runtime data. p. 1
Where the paper says it

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.

The resulting proof of data transformation is referred to as an exclave data record (EDR). p. 1
Where the paper says it

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.

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

Where the paper says it

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.

Specific claims include verifying that a data provider has performed a specific sanitization step by comparing the input dataset commitment against the set of data commitments produced by the sanitization task. p. 7
Where the paper says it

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.

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

Where the paper says it

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.

While VerifiableFL is slower than NVFlare (CVM) in some cases, its overhead stays low across various models, with LeNet having a slightly higher overhead because its small model requires little training time. p. 9
Where the paper says it

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.

The auditing process incurs negligible overhead, taking only 19 seconds to verify all EDR signatures and construct the EDG when scaling to 100 clients and 1,000 rounds.

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

Where the paper says it

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.

Secure storage uses Linux’s dm-verity to protect datasets, and the Runtime Attestor constructs the EDR by recording a hash of each data item together with metadata describing its intended usage and properties. p. 8
Where the paper says it

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 system emulates hardware attestation using a virtual Trusted Platform Module (vTPM) as a secure processor in AMD SEV-SNP. p. 8
Where the paper says it

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.

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

Where the paper says it

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.

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. p. 0
Where the paper says it

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.

p. 0
Where the paper says it

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.

Exclaves produce EDRs which can be combined to create an exclave dataflow graph (EDG) that spans the entire FL job. p. 6
Where the paper says it

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).

p. 6
Where the paper says it

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).

An auditor uses the EDG to verify end-to-end claims about the FL job. p. 5
Where the paper says it

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 system can detect a wide range of deviations with low runtime overhead. p. 0
Where the paper says it

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.

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

Where the paper says it

2); (ii) how does VerifiableFL scale with an increased number of data providers and GPUs? 3); (iii) what is the performance breakdown of VerifiableFL?

5 Overhead of runtime attestation, 7. p. 1
Where the paper says it

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.

6 Overhead of secure storage, 7. p. 8
Where the paper says it

4); (iv) what overhead does VerifiableFL’s runtime attestation add? 5); (v) what is the impact of secure storage on throughput and latency?

7 Overhead of auditing, 8 Related Work, 9 Conclusions

--- 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

Where the paper says it

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.

g., 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. p. 0
Where the paper says it

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.

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. p. 0
Where the paper says it

, 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.

The confidentiality guarantees of TEEs, however, have been shown to be vulnerable to a wide range of attacks, such as side-channel attacks. p. 0
Where the paper says it

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.

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. p. 0
Where the paper says it

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.

Since these runtime attestation proofs only require integrity protection, VerifiableFL generates them using the new abstraction of exclaves. p. 0
Where the paper says it

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.

Exclaves are integrity-only execution environments, which do not contain software-managed secrets and thus are immune to data leakage attacks. p. 0
Where the paper says it

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.

VerifiableFL uses exclaves to attest individual data transformations during FL training without relying on confidentiality guarantees. p. 0
Where the paper says it

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.

The runtime attestation proofs then form an attested dataflow graph of the entire FL model training computation. p. 0
Where the paper says it

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 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. p. 0
Where the paper says it

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.

VerifiableFL extends NVIDIA’s NVFlare FL framework to use exclaves. p. 0
Where the paper says it

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.

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. p. 0
Where the paper says it

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.

We show that VerifiableFL introduces less than 12% overhead compared to unprotected FL model training. p. 0
Where the paper says it

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.

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

Where the paper says it

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. p. 0
Where the paper says it

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.

g. cleaning, filtering etc. p. 0
Where the paper says it

] including the type and provenance of data and curation methodologies (e. 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”. p. 0
Where the paper says it

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”.

In response to such requirements, datasheets for datasets [23] describe the composition of training datasets, and model cards [49] describe model training. p. 0
Where the paper says it

), 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.

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. p. 0
Where the paper says it

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.

g., the model card for OpenAI’s GPT-5 describes how the training data was preprocessed to remove personal information [53]. p. 0
Where the paper says it

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].

Such claims may be relevant to model providers as well as downstream users. p. 0
Where the paper says it

, 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.

At present, such claims about model training and datasets are made without proof and thus cannot be verified. p. 0
Where the paper says it

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.

For closed-source models, it is impossible to verify claims when interacting with the model via an inference API. p. 0
Where the paper says it

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.

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. p. 0
Where the paper says it

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.

Today, model claims are therefore accepted based on the reputational trust in model providers. p. 0
Where the paper says it

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.

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. p. 0
Where the paper says it

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.

Claims about models trained using FL thus require reputational trust in all data providers, as well as the model provider. p. 0
Where the paper says it

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.

--- 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

Where the paper says it

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.

In FL training systems with TEEs, 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. p. 1
Where the paper says it

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.

(2) Existing attestation relies on confidentiality. p. 1
Where the paper says it

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.

As we show, TEE implementations rely on confidentiality to provide unforgeable attestation proofs. p. 1
Where the paper says it

(2) Existing attestation relies on confidentiality. As we show, TEE implementations rely on confidentiality to provide unforgeable attestation proofs.

--- 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

Where the paper says it

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.

Importantly, these runtime attestation proofs only require guarantees about the integrity of data transformations and not their confidentiality. p. 1
Where the paper says it

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.

To realise the above approach, our work makes the following two contributions. p. 1

Where the paper says it

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.

(1) We describe a new abstraction called an exclave, which is a hardware-based integrity-only execution environment. p. 1
Where the paper says it

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 to measure code integrity and sign an attestation statement at runtime that can include other runtime data. p. 1
Where the paper says it

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.

(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. p. 1
Where the paper says it

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.

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. p. 1
Where the paper says it

(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.

--- 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

Where the paper says it

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.

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. p. 1
Where the paper says it

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.

--- 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

Where the paper says it

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.

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. p. 3
Where the paper says it

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 are to ensure that any participant or third-party auditor is unable to deviate from the predefined FL training protocol without detection. p. 3
Where the paper says it

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, 4

--- 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

Where the paper says it

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.

--- 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

Where the paper says it

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.

--- 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

  1. 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.

  1. 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.

  1. 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.

  1. 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.

  1. 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.

  1. 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

Related papers