TL;DR

FheFL is a single-server privacy-preserving federated learning protocol that combines a distributed multi-key CKKS-based additive HE scheme with a non-poisoning-rate weighted aggregation rule, so the aggregator can mitigate data-poisoning Byzantine clients while operating entirely on encrypted gradients [§1, §4]. Across MNIST/CIFAR-10/CIFAR-100 with up to 20% label-flipping attackers, it matches or beats FedAvg, Trimmed Mean, Median, and KRUM in accuracy while keeping individual gradients encrypted [§6.1.2, Table 3].

Problem and motivation

In federated learning the server can reconstruct private training data from plaintext local gradients (e.g. Deep Leakage from Gradients attacks) [§1, §6.2.1]. Encrypting gradients fixes that privacy leak but creates a new security problem: the aggregator can no longer see the gradients, so malicious clients can submit poisoned updates undetected [§1]. Prior joint-defence works rely on two non-colluding servers, all-pair user-to-user secure computation, or all-or-nothing group exclusion [§1, §2.3, Table 1]. The threat model assumes (i) a semi-honest single aggregator that may collude with up to (U−2) users, requiring at least two non-colluding users for privacy [§5.1], and (ii) up to 20% malicious clients launching data-poisoning (label-flipping) attacks [§5, §6.1.2].

Key contributions

FHE setup

ML setup

Datasets

Dataset Task Size (train/test) Modality Notes
MNIST Digit classification (10 classes) 60,000 / 10,000 Grayscale images Evenly split across 100 users; label-flip “1”↔”7” attack; 200 sync rounds [§6.1.1, §6.1.2]
CIFAR-10 Image classification (10 classes) 50,000 / 10,000 (paper states 60,000 total balanced) Color images ResNet-18; label-flip “Cat”↔”Dog”; 200 rounds [§6.1.1, §6.1.2]
CIFAR-100 Image classification (100 classes) 60,000 total balanced Color images ResNet-18; label-flip “Chair”↔”Couch”; 500 rounds [§6.1.1, §6.1.2]

Pipeline diagram

flowchart LR
    subgraph Setup
        K[Pairwise key share s_uj] --> KU[User shared secret s_u]
    end
    subgraph Client_u [Client u]
        L[Local train 5 epochs] --> G[Compute gradient]
        G --> E[CKKS encrypt with s_u]
        E --> SS[Build ss_u = s_u + sum s_uj]
    end
    subgraph Server
        D[Encrypted Euclidean dist d_u]
        D --> SUM[Sum d_u over users]
        SUM --> DEC1[Decrypt sum d_u via sum ss_u]
        DEC1 --> NPR[Non-poisoning rate p_u enc]
        NPR --> W[Weight p_u times grad enc]
        W --> AGG[Sum weighted grads]
        AGG --> DEC2[Decrypt aggregate]
        DEC2 --> UPD[Update global w_i+1]
    end
    E -. ciphertext .-> D
    SS -. shared secret .-> DEC1
    UPD -. plaintext w .-> Client_u

Pipeline steps (text)

  1. Server initialises global model w_0, defines CKKS parameters (N, q, Δ, L), and distributes w_0 to all U users [Algorithm 1, Algorithm 2].
  2. At join time, every pair (i, j) of users exchanges a pairwise secret s_{i,j} = −s_{j,i} (e.g. via Diffie-Hellman); each user u also generates its own random share s_u [§4.2].
  3. Each selected user u trains locally for 5 epochs, computes gradient ∇L_u(w_i, ζ_u^j), encrypts it under its own share s_u with CKKS, and uploads the ciphertext together with ss_u = s_u + Σ_{j≠u} s_{u,j} to the server [Algorithm 2, lines 6-10].
  4. Server homomorphically computes [d_u] = [∇L_u]^T · [∇L_u] for each user, still encrypted under s_u (Byzantine-defence step in ciphertext) [§4.4, eq. (12); Algorithm 3, line 2].
  5. Server sums [d_u] across users; the sum is encrypted under Σ s_u = s, which the server can decrypt using Σ ss_u (the s_{u,j} cancel because s_{i,j} = −s_{j,i}) [§4.2 eq. (11); Algorithm 3, lines 3-4].
  6. Server computes the encrypted non-poisoning rate [p_u^i] = (1/(U−1)) · (1 − [d_u]/Σ d_j) per user [§4.4, eq. (13); Algorithm 3, line 6].
  7. Server multiplies [p_u^i] · [∇L_u] homomorphically (still under s_u), then sums across all users so the aggregate is under Σ s_u and decryptable via Σ ss_u [Algorithm 3, lines 7-9].
  8. Server applies w_{i+1} = w_i − η^i · Σ p_u^i · ∇L_u and broadcasts the updated plaintext global model; loop until   w_{i+1} − w_i   ≤ ε [Algorithm 2, lines 11-13].

Architecture diagram

Two architectures are evaluated. The encrypted protocol only protects first-layer gradients; the rest of the model is trained in plaintext locally.

CNN (MNIST)

flowchart LR
    I([Input 1x28x28]) --> C1[Conv 32, 3x3]
    C1 --> R1[ReLU]
    R1 --> C2[Conv 64, 3x3]
    C2 --> R2[ReLU]
    R2 --> P[MaxPool]
    P --> F[Flatten]
    F --> FC1[FC 9216]
    FC1 --> R3[ReLU]
    R3 --> FC2[FC 128]
    FC2 --> O([Softmax 10])

ResNet-18 (CIFAR-10 / CIFAR-100)

flowchart LR
    I([Input 3x32x32]) --> C0[Conv 64, 3x3]
    C0 --> B1[ResBlock x2 64ch]
    B1 --> B2[ResBlock x2 128ch]
    B2 --> B3[ResBlock x2 256ch]
    B3 --> B4[ResBlock x2 512ch]
    B4 --> GAP[GlobalAvgPool]
    GAP --> FC[FC]
    FC --> O([Softmax 10 or 100])

Results

Metric This paper Baseline Hardware
MNIST accuracy, 100 users, 0% attackers 98.78% FedAvg 98.68%, KRUM 96.34%, Median 96.88%, Trimmed Mean 96.48% [Table 2] Intel i7-4210U @ 4.1GHz, 16GB RAM
MNIST accuracy / AASR, 20% attackers 97.32% / 1.78% FedAvg 84.54% / 12.21%, KRUM 86.93% / 20.32% [Table 3] same
CIFAR-10 accuracy / AASR, 20% attackers 84.59% / 4.24% FedAvg 80.15% / 22.58%, KRUM 69.05% / 26.69% [Table 3] same
CIFAR-100 accuracy / AASR, 20% attackers 52.85% / 2.34% FedAvg 46.78% / 62.35%, KRUM 28.65% / 70.32% [Table 3] same
Encrypted vs plain accuracy loss, 100 users 2.7% (N=16384), 6.5% (N=8192) [17] ShieldFL ≈4%, [15] PEFL ≈3.5% [Table 5] same
Aggregation time, 10 users, 8192 gradients, N=16384 ~30 s ShieldFL [17] >1 hour on similar hardware [§6.3] Intel i7-4210U @ 4.1GHz
Per-user uplink bandwidth <3 MB / epoch ShieldFL ≈2× higher; PEFL slightly lower than FheFL; one-time-pad schemes [18][19] much lower [§6.4, Figure 6] same

Convergence rounds: ~50 (MNIST), 125-150 (CIFAR-10), 200-220 (CIFAR-100) [§6.1.2].

Limitations and assumptions

So et al. [14] (Byzantine-resilient SFL), Liu et al. PEFL [15], Z. Ma et al. ShieldFL [17] (two-trapdoor Paillier, two servers), H. Ma et al. MUD-PQFed [16], Jebreel et al. Fragmented FL [18], Zhang et al. LSFL [19], J. Ma et al. multi-key FHE FL [6], J. Park et al. third-party-assisted FHE FL [7]. Plain-domain Byzantine baselines: FedAvg [32], Trimmed Mean [33], Median [33], KRUM [12]. DLG attacks [36], [37] are used to probe privacy.

Code and artifacts

Not released (no repository URL stated in the text). Implementation is described as built on a modified TenSEAL [28] and PyTorch [§6].

Extra diagrams (optional)

Threat model

flowchart LR
    Cb[Benign clients] -- enc grad under s_u --> S[Single server]
    Cm[Malicious clients <=20%] -- enc poisoned grad --> S
    Cc[Colluding clients <=U-2] -- s_u, s_uj leaked --> S
    S -- plaintext w_i+1 --> Cb
    S -- plaintext w_i+1 --> Cm

Federated round

sequenceDiagram
    participant C as Clients (selected 10/100)
    participant S as Aggregator
    S->>C: plaintext global w_i
    C->>C: local SGD 5 epochs
    C->>S: enc grad [grad_u] + ss_u
    S->>S: enc squared dist [d_u]
    S->>S: sum [d_u], decrypt via sum ss_u
    S->>S: enc non-poisoning rate [p_u]
    S->>S: sum [p_u * grad_u], decrypt
    S->>S: w_i+1 = w_i - eta * sum p_u grad_u
    S->>C: plaintext w_i+1

Open questions