acceptodds
Under review as a conference paper at ICLR 2027

FedAttr: Towards Privacy-preserving Client-Level Attribution in Federated LLM Fine-tuning

Abstract

Data owners often need a way to verify whether a released corpus is used for unauthorized model training purposes by users. Training-data watermarking enables such verification via modifying the corpus so that models trained on it exhibit a detectable signal. In federated learning (FL), the global model aggregates updates from multiple clients, thus detecting the training-data watermark in the global model is feasible to check the corpus usage, but cannot identify which clients used it, which is the task we call client-level watermark attribution. Testing each client's locally updated model individually would reveal such attribution, but would also expose the client's update with privacy concern. Secure aggregation (SA) protects the individual updates via only exposing their aggregation but hides client-specific detection information which is needed for attribution, i.e. preventing the data owner from identifying which clients used the corpus. We propose FedAttr, a client-level watermark attribution protocol for FL with using the secure aggregates. For each target client, FedAttr contrasts aggregates from random subsets that include or exclude the client, yielding an unbiased update estimate with bounded variance. It then applies differential watermark scoring and combines evidence across communication rounds. We prove exponential attribution error bounds and bound the estimator's per-round mutual-information leakage by . In federated LoRA fine-tuning, FedAttr achieves 100% TPR at 0% FPR within five rounds across two watermark families and two aggregation strategies, outperforming all baselines, with 6.3% overhead.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
FL, Watermark, Secure Aggregation

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_SJ19OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies client-level training-data watermark attribution in federated LLM fine-tuning under secure aggregation (SA). The key challenge is that SA prevents direct inspection of individual client updates and therefore obscures which clients were responsible. The paper proposes FedAttr, which repeatedly queries secure aggregates over random client subsets that include or exclude a target client, and uses the difference of these subset averages to construct an unbiased estimate of that client’s update. FedAttr then applies differential watermark scoring, comparing the watermark score before and after adding the estimated update, and combines evidence across communication rounds using Stouffer aggregation. The empirical evaluation shows that FedAttr can successfully attribute to the client while maintaining a low FPR.

Critical strengths
  1. The paper targets a clear and underexplored attribution problem created by secure aggregation.
  2. FedAttr is technically well structured and supported. The methodology is reasonable, and the experimental results validate its effectiveness.
Critical weaknesses
  1. FedAttr deliberately constructs an unbiased estimator of each client's update from repeated overlapping aggregate queries, which appears to conflict with the purpose of secure aggregation. Moreover, the estimator variance decreases as the number of queries M increases, suggesting that stronger attribution is obtained by progressively recovering more information about the individual update. The current mutual-information analysis does not fully resolve this concern. It is therefore unclear in what meaningful sense FedAttr preserves client-update privacy beyond avoiding exact plaintext disclosure.

  2. FedAttr requires 2MKT=500 SA queries even in the default setting with only 10 clients, yet the paper reports only about five minutes of SA-query overhead and does not describe a concrete cryptographic SA implementation. To my knowledge, if these queries were implemented using an actual SA protocol, client-side computation, communication, cryptographic setup, synchronization, and repeated participation could introduce substantially higher costs.

Questions for authors
  1. What SA protocol was actually used in the experiments? Were the reported SA queries implemented using a real cryptographic SA protocol?

  2. The KGW experiments use client-specific secret keys sis_i, with one key assigned to each watermarked client. Since the violating clients are assumed to be unknown, how does the verifier determine which key should be used for an arbitrary candidate client, particularly for benign clients that have no assigned watermark key?

  3. Would FedAttr remain effective if a violating client attempted simple watermark-removal or evasion strategies, such as paraphrasing the protected documents before local training?

  4. The current protocol sends both global-model checkpoints and client-specific update estimates to the corpus owner. Since both evaluated watermark detectors operate through black-box model queries, is transferring these model artifacts actually necessary?

Reviewer_DVoUOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper asks which FL clients trained on a watermarked corpus when secure aggregation (SA) hides individual updates. A test on the global model can show that the corpus was used, but not by whom. FedAttr estimates each client's update by differencing SA sums over random subsets that include and exclude the client. It then scores the estimate against the current global model and sums the scores across rounds. The paper proves that the estimator is unbiased, gives error bounds under an assumed separation condition, and bounds the per-estimate mutual-information leakage by O(d*/N).

In federated LoRA fine-tuning of Llama-3.2-3B with 10 clients, FedAttr reaches 100% TPR and 0% FPR for two watermark types and two aggregation rules, while direct scoring on plaintext updates has an FPR of 57–71%. The ablations mostly preserve this result, except under severe non-IID data or with very few queries.

Critical strengths

Strength 1: The problem setting is new. Huang et al. (arXiv 2510.17033) show that watermarked data can be detected in a federated global model, and FL watermarking work such as FedTracker traces who leaked a model. Neither asks which client used a protected corpus. To my knowledge this paper is the first to do so, and the question is practically relevant for data licensing.

Strength 2: The method is simple and works well in the tested setting. The key piece is differential scoring. Since the global model already carries watermark signal from earlier rounds, scoring a client's model directly also flags benign clients, and Table 1 shows 57–71% FPR even on plaintext updates. Subtracting the global model's score removes this bias. The results hold across two watermark families, two aggregation rules, several models and datasets, and up to 100 clients.

Critical weaknesses

Weakness 1: The privacy claim does not hold. In each round the server sees 100 subset sums of only 10 client updates, so it can recover every update exactly by solving a linear system. Once the queries are known, the corpus owner can do the same from the released estimates. Kerkouche et al. at WPES 2023 exploit a closely related idea as an attack on SA. Theorem 4 bounds the leakage of only a single estimate, and at the default setting this bound is of order d*, which is vacuous for LoRA-sized updates. No experiment measures privacy. This weighs most in my assessment because privacy under SA is what the paper claims to add over scoring plaintext updates. Without it, the attribution works mainly because the estimates are close to the plaintext updates.

Weakness 2: The setting relies on a cooperative server, and the paper does not justify this. FedAttr needs the server to run extra queries every round and hand per-client estimates to an outside corpus owner, who cannot verify them. In practice the server usually owns the model that benefits from the violation, and Huang et al. treat such a server as an adversary that filters out the watermark signal. Without a deployment where the server would cooperate, it is unclear that the problem FedAttr solves arises in practice.

Questions for authors
  1. The server's subset sums, and the K released estimates once the queries are known, determine every client update exactly. Beyond the per-estimate bound in Theorem 4, what privacy does FedAttr actually provide? Could you report a reconstruction or membership-inference attack on the released quantities?
  2. Which SA protocol supports many different subset sums per round? Was the 0.6 s per query measured with a real cryptographic SA implementation?
  3. In what deployment would the server agree to run FedAttr and hand the estimates to the corpus owner, and how could the owner verify them?
  4. How does FedAttr compare with testing the global model once per key? How does it perform when all violating clients share a single key?
  5. Could you report plaintext updates with differential scoring as the oracle? Could you also estimate the null distribution of ZiZ_i, for example with a key never inserted into any data, to calibrate γ\gamma and the reported p-values?
Reviewer_zYcqOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

FedAttr aims to identify which clients used watermarked training data during federated LLM fine-tuning with secure aggregation. The server estimates each client's update from repeated aggregate queries that include or exclude that client. A corpus owner compares watermark scores with and without the estimated update and combines the differences across rounds. The paper analyzes the estimator and its information leakage, and evaluates two watermark families with two federated aggregation methods. It reports 100% TPR and 0% FPR in the four default settings, together with parameter and training-configuration ablations.

Critical strengths
  1. A watermark in the global model does not identify which client used the protected corpus. FedAttr addresses this attribution problem through paired aggregate queries.
  2. The direct-scoring comparison shows that reference-score subtraction reduces false positives from the global model's accumulated watermark signal. The estimator analysis also explains how subset size and query count affect noise.
Critical weaknesses
  1. The server can recover an individual update from outputs that pass the protocol's checks. The rejection rule constrains the averaged estimate, but an accepted batch can still contain an include/exclude pair with identical non-target clients. Subtracting these two authorized sums reveals the target update exactly. The leakage bound for one estimate therefore does not establish privacy against the server's full view.
  2. The standard normal p-values are not justified by the stated assumptions. Theorem 3 provides a sub-Gaussian error bound, which does not establish a standard normal null for the combined differential score. These p-values need separate calibration.
Questions for authors
  1. What restriction prevents the server from subtracting two accepted aggregate outputs that differ only by the target client, or from reconstructing updates using the full same-round query set?
  2. How is the combined differential score calibrated under the null, and what justifies the standard normal p-values?
  3. How were the N=1, 2, and 4 ablations authorized under N_sa=5? Was the threshold changed for these runs?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.