Skip to main content
Skip to content
Machine Learning

Secure Model Aggregation

The part of federated learning that combines each participant's model update without anyone, including the coordinator, seeing a single one. The guarantee that makes the rest of the protocol trustworthy.

01 / 04

The updates leak what the data hides

A model update can be reversed into parts of the records behind it. The coordinator sees every one. A poisoned update looks like any other. Keeping data at home is not enough if the update travels in the clear.

CH.01 · The problem

The updates leak what the data was supposed to hide.

  1. An update can be reversed

    A model update from one site is a function of that site's records. With enough care, parts of those records can be reconstructed from it. Keeping the data at home is not enough if the update travels in the clear.

  2. The coordinator is a target

    Whoever runs the aggregation sees every update. Compromise that machine, or that operator, and every participant's contribution is exposed.

  3. Nobody can check anyone

    A participant can send a poisoned update. Without verification the coordinator cannot tell a bad contribution from a good one, and the global model absorbs it.

Our answer

Combine the updates without reading them

Secure aggregation masks each update so that only the sum of all of them can be recovered. The coordinator computes the combined model and learns nothing about any single site. Verification and drop-out handling keep the round honest when participants misbehave or disappear.

CH.02 · What we build

How we build it

Three parts: the privacy of each update, the security of the round, and the trust between participants.

No single update is ever visibleHolds against a curious coordinatorSurvives drop-outsPoisoned updates caught
01

Privacy protection

Only the sum is ever recoverable.

  • Choose the masking protocol for the number of participants
  • Distribute the shared secrets among the sites
  • Mask each update before it leaves the site
  • Recover the sum, and only the sum, at the coordinator
  • Add differential privacy noise where the guarantee requires it
02

Security enforcement

The round completes correctly or not at all.

  • Authenticate every participant each round
  • Encrypt all traffic between sites and coordinator
  • Handle drop-outs without exposing contributions
  • Bound each update before it is masked
  • Abort and log when checks fail
03

Trust architecture

Participants can verify, and nobody has to trust the middle.

  • Publish the protocol and the guarantee to all participants
  • Let each site verify the aggregate it receives
  • Log rounds for each participant's own audit
  • Keep the coordinator unable to learn more than the sum
  • Review the setup with each participant's security team
CH.03 · How it runs

How it runs

Four phases from a federated set-up to secure rounds in production.

  1. 01Phase 1

    Assessment

    Participants, threat model, guarantee.

    • Map the participants and their trust relationships
    • Define who could attack, and how
    • Agree the privacy guarantee per participant
  2. 02Phase 2

    Protocol design

    The masking and verification, specified.

    • Choose the secure aggregation scheme
    • Design the key and secret distribution
    • Specify bounds and checks per update
  3. 03Phase 3

    Integration

    Into the federated clients and coordinator.

    • Implement masking in the site client
    • Implement recovery at the coordinator
    • Add authentication and encryption
  4. 04Phase 4

    Deployment and monitoring

    Secure rounds, watched.

    • Run the first secure rounds with all participants
    • Monitor round completion and aborts
    • Log for each participant's audit
CH.04 · What changes

What changes

Federated learning that participants and their lawyers can accept.

The updates reveal nothing

What leaves each site cannot be reversed into records, even by the coordinator. The privacy argument holds all the way through the protocol.

Participants who do not trust each other can still cooperate

Competitors, hospitals in different groups, agencies in different countries. Nobody needs to trust the middle or each other, only the protocol.

Bad actors are contained

Bounds, verification and logging limit what a poisoned update can do and make it visible when one arrives.

Side by sidePlain aggregationSecure aggregation
What the coordinator seesEvery site's updateOnly the sum
If the coordinator is compromisedAll contributions exposedStill only the sum
Trust neededIn the operator and every participantIn the protocol
A site that drops outRound fails or leaksRound completes, nothing exposed
Poisoned updateAbsorbed unseenBounded, checked, logged
CH.05 · Questions

Questions

It adds computation at each site for masking and some traffic for the shared secrets. For the participant counts typical of organisations, tens of sites rather than millions of devices, the overhead per round is modest and the rounds are dominated by training time. We measure it in the integration phase and report it.

No. It stops the coordinator and other participants from learning any single site's update. It does not by itself stop what the final global model can reveal, which is what differential privacy is for, and it limits rather than eliminates poisoning, which bounds and verification address. The assessment names the threats and which mechanism covers each.

The protocol is designed for it. The remaining participants hold enough of the shared secrets to cancel the missing site's mask, so the sum can still be recovered without revealing anyone's contribution. Below an agreed minimum number of participants, the round is aborted and logged.

Each update is bounded before it is masked, so a single site cannot push the global model arbitrarily far. Checks on the aggregate and on round statistics flag anomalies. Participants are authenticated every round, and a site that fails checks repeatedly can be excluded. The logs let every participant see when it happened.

More in Machine Learning

The map of the practice

Back to Machine Learning
Start

Bring us the problem nobody has cracked yet.

We are a small team of senior specialists. We pick the right model and the right layer, and we build the least machinery that does the job. You get a call with an engineer, not a sales deck.