Secure Aggregation for Privacy Preserving Federated Learning

This direction is split into other directions: secure gradient aggregation. Its last version stays readable and citable here.

Version 1 of 1412 papers502 conceptsfrozen 2026-10-04

In standard Federated Learning (FL), a central server coordinates training by sending a global model to clients, who compute updates on their local data and send them back. While the raw data never leaves the device, the updates themselves—often gradients or model weights—are surprisingly "chatty." Research has shown that an honest-but-curious server can use techniques like gradient inversion to reconstruct sensitive training images or text from these updates.

To close this loophole, researchers have developed Secure Aggregation (SecAgg): a suite of cryptographic protocols that allow a server to compute the sum of client updates without ever seeing an individual contribution.

The Intuition of Masking and Secret Sharing

The most intuitive way to understand secure aggregation is through "zero-sum masking." Imagine two clients, Alice and Bob. Alice adds a large random number $r$ to her update, and Bob subtracts the same number $r$ from his. When the server adds their masked updates together, the $r$ and $-r$ cancel out, leaving only the true sum.

Yan Feng and colleagues in A Practical Privacy-preserving Method in Federated Deep Learning demonstrate how these zero-sum masks can be applied to deep learning gradients. Because addition is linear, the masks disappear during the aggregation phase, allowing the server to recover the global gradient while individual data points remain obscured.

For more complex scenarios involving thousands of users, researchers often turn to Shamir’s Secret Sharing. In this setup, a client’s update is broken into "shares" and distributed among peers or multiple servers. No single share reveals anything about the original update, but a quorum of shares can reconstruct the sum. Xiangman Li and Jianbing Ni utilize this in PDLRecover to allow decentralized systems to "unlearn" malicious updates without compromising the privacy of the remaining honest participants.

Computing on Encrypted Data

While masking is efficient, it often requires complex coordination between clients. An alternative is Homomorphic Encryption (HE), which allows the server to perform mathematical operations directly on encrypted values. The result of the operation remains encrypted and can only be decrypted by the clients who hold the keys.

This approach is particularly valuable in high-stakes fields like healthcare. Xiang Bai and the team behind the UCADI initiative used additive homomorphic encryption to train COVID-19 diagnostic models across international borders. By encrypting model weights, they ensured that patient CT scans remained private within their home institutions while still contributing to a global diagnostic tool.

However, HE is computationally expensive. To address this, Miao Pan and Zilong Zhang proposed PPML-Hybrid, a framework where clients with high compute power use HE for precision, while resource-constrained devices use faster, noise-based Differential Privacy (DP).

Scaling to Production and Large Models

In real-world deployments, secure aggregation must handle "stragglers"—devices that drop offline mid-training. Reent Schlegel and Alexandre Graell i Amat introduced CodedSecAgg, which uses coding theory to inject redundancy into the secret shares. This allows the server to reconstruct the aggregate sum even if a significant portion of the clients fail to respond.

For massive models, the communication cost of sending full gradients is prohibitive. Chaoyue Niu and Fan Wu developed Secure Federated Submodel Learning (SFSL), where clients only download and update the specific "submodels" relevant to their data. They use a Private Set Union protocol to ensure the server doesn't even know which parts of the model a user is training on, protecting user interests and reducing overhead by 80%.

The Hybrid Privacy Frontier

The current state-of-the-art involves combining these techniques to provide "defense in depth." Zheng Xu and Galen Andrew describe how Google’s Gboard language models use a combination of Secure Aggregation and Differential Privacy.

In this hybrid model:

  1. Secure Aggregation ensures the server only sees the aggregate sum of a large cohort (e.g., 1,000 users).
  2. Differential Privacy adds a calibrated amount of noise to that sum, ensuring that even the aggregate result doesn't leak whether a specific individual's unique phrase was part of the training set.

By moving from "moving data to models" to "moving models to data" and securing the return trip with these cryptographic protocols, researchers like Chao Wu in Galaxy Learning are building a future where collaborative AI doesn't require a foundation of shared trust, but rather a foundation of shared math.

Papers in this version

Showing 60 of 412 papers.

History & citationVersion 1 · 2026-10-04

Split into other directions · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_secure_aggregation_for_privacy_preservin_6b298cb5,
  title = {Secure Aggregation for Privacy Preserving Federated Learning},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/secure-aggregation-for-privacy-preserving-federated-learning/rdr_6b298cb5518148938f38a883e4704cc0},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_secure_aggregation_for_privacy_preservin_6b298cb5_v1,
  title = {Secure Aggregation for Privacy Preserving Federated Learning},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/secure-aggregation-for-privacy-preserving-federated-learning/rdr_6b298cb5518148938f38a883e4704cc0/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}