TL;DR

BlindFL is a federated learning protocol that has each client encrypt and send only a random subset of its local parameter matrices (Client Model Segmentation, CMS) under single-key CKKS before server-side weighted averaging, cutting server aggregation time roughly in half while degrading neither model accuracy nor security against an honest-but-curious server, and additionally raising the cost of state-of-the-art malicious-client gradient-inversion attacks [§Abstract, §7].

Problem and motivation

Standard federated learning leaks training data through gradient-inversion attacks (GIAs); FHE-based FL hides updates from the server but is expensive, and existing single-key FHE-FL schemes do not defend against malicious clients inside the federation, who can poison the decrypted global model to isolate per-sample gradients and reconstruct private data [§1, §2.3, §5]. Threat model: a malicious adversary A with white-box access to either the server or a subset c of C clients, with knowledge of the data distribution’s mean/std; the paper focuses on the c-of-C compromised-clients case, since FHE already provably blocks server-side attacks for single-key schemes [§2.3, §5].

Key contributions

FHE setup

ML setup

Datasets

Dataset Task Size (train/test) Modality Notes
MNIST [7] Digit classification Standard split, randomly shuffled and partitioned evenly across clients 28x28 grayscale images LeNet-5 model; client count varied 2-10 [§6, §6.2]
CIFAR-10 [21] 10-class image classification Standard split, randomly shuffled and partitioned evenly across clients 32x32 RGB images ResNet-20 model; client count varied 2-10 [§6, §6.2]

Pipeline diagram

flowchart LR
    subgraph KeyDist [Key Distributor]
        K1[Generate K_pub, K_priv per round]
    end
    subgraph Clients
        C1[Local train on D_i] --> C2[Receive R_i, K_pub]
        C2 --> C3[Encrypt requested w_i,j]
        C3 --> C4[Send Enc w_i,j, t_i,j]
        C5[Decrypt Enc W with K_priv]
    end
    subgraph Server
        S1[Generate request matrix R] --> S2[Send R_i to each client]
        S3[Weighted avg of Enc segments] --> S4[Broadcast Enc W]
        S3 --> S5[Notify KD: aggregation done]
    end
    K1 -. K_pub .-> C2
    C4 -. ciphertext .-> S3
    S2 --> C2
    S5 --> K1
    K1 -. K_priv .-> C5
    S4 -. ciphertext .-> C5

Pipeline steps (text)

  1. KD generates a fresh CKKS keypair (K_pub, K_priv) for the round and shares K_pub with all participating clients [§4.2, Protocol 1].
  2. Server runs Generate-Request-Matrix(M, c, p) to choose, per client, which parameter matrices to submit such that every global matrix receives at least p contributions [§4.1, Algorithm 1].
  3. Each of c selected clients trains locally, then encrypts only the requested parameter matrices w_i,j (and reports per-class example counts t_i,j) under K_pub [§4.1, §4.2, Protocol 1].
  4. Clients send Enc(w_i,j), t_i,j, and K_pub to the server [Protocol 1, step 10].
  5. Server homomorphically computes W_j = sum_i (w_i,j * t_i,j) / sum_i t_i,j for every global matrix j [§4.1, Algorithm 3].
  6. Server signals the KD that aggregation is finished; KD releases K_priv to each client [Protocol 1, step 12].
  7. Server broadcasts Enc(W) to all C clients, who decrypt with K_priv to obtain the updated global model [Protocol 1, steps 14-16].
  8. Repeat for the next round with a new keypair (experiments use 50 rounds) [§6.4].

Architecture diagram

Two models are used; both run plaintext locally and only their parameter matrices traverse FHE.

LeNet-5 (MNIST)

flowchart LR
    I([Input 1x28x28]) --> C1[conv1 6, 5x5]
    C1 --> C2[conv2 16, 5x5]
    C2 --> C3[conv3 120, 5x5]
    C3 --> F[Flatten]
    F --> FC1[fc1 120 to 84]
    FC1 --> FC2[fc2 84 to 10]
    FC2 --> O([Softmax])

Parameter matrices per Table 1: conv1.weight/bias, conv2.weight/bias, conv3.weight/bias, fc1.weight/bias, fc2.weight/bias — 10 matrices, 545,546 params, 2,183,464 bytes [§6, Table 1].

ResNet-20 (CIFAR-10)

flowchart LR
    I([Input 3x32x32]) --> C0[Conv 16, 3x3]
    C0 --> S1[Stage1 BasicBlock x3 16ch]
    S1 --> S2[Stage2 BasicBlock x3 32ch]
    S2 --> S3[Stage3 BasicBlock x3 64ch]
    S3 --> AP[Global AvgPool]
    AP --> FC[FC 64 to 10]
    FC --> O([Softmax])

ResNet-20 from He et al. [11], 128 parameter matrices, 284,426 parameters total [§6, §6.5].

Results

Headline accuracies (5-trial avg, 50 rounds, 10 clients):

Metric This paper (BlindFL: FHE+CMS) FL+FHE only Standard FL FL+CMS only Hardware
MNIST acc (LeNet-5, p=3) 98.53% 98.82% 98.71% 98.56% c5.18xlarge (72 vCPU, 144 GiB) [§6, Table 5]
MNIST round aggregation time 49.94 s 139.18 s 1.80 s 0.65 s same [Table 5]
MNIST acc (LeNet-5, 5 matrices) 98.66% 98.82% 98.79% 98.72% c5.18xlarge [Table 4]
MNIST round aggregation time (5 matrices) 75.97 s 139.14 s 1.80 s 1.00 s same [Table 4]
CIFAR-10 acc (ResNet-20, 30% matrices) 77.53% 78.57% 79.50% 77.20% c5.24xlarge (96 vCPU, 192 GiB) [Table 6]
CIFAR-10 round aggregation time (30%) 102.31 s 275.91 s 12.42 s 4.43 s same [Table 6]
CIFAR-10 acc (ResNet-20, 50% matrices) 78.69% 79.42% 79.92% 79.14% c5.24xlarge [Table 7]
CIFAR-10 round aggregation time (50%) 153.65 s 276.79 s 12.43 s 6.76 s same [Table 7]
Per-client data sent, MNIST 5 layers 29,888 KB 29,888 KB (FHE) / 1,091 KB no-FHE — — [Table 8]
Per-client data sent, CIFAR-10 50% 61,350 KB — — — [Table 9]

Vary-client-count headline (Table 2, 50 rounds, p = ceil(n/2)): MNIST stays at 98.70-98.81% across 2-10 clients; CIFAR-10 stays 76.35-78.74% [§6.2, Table 2].

GIA defense (§6.6, Figures 11/13): as the number n of layers in the attacked gradient drops, PSNR and SSIM of the GIA reconstruction decay exponentially on both MNIST and CIFAR-10; the authors recommend r = n/N <= 2/3 for meaningful client-to-client protection.

Note: the paper reports server-side aggregation latency per round, not single-sample inference latency — inference happens in plaintext at clients. comparison.single_inference_seconds is therefore N/A.

Limitations and assumptions

Positions against FedAvg (McMahan et al.) [27]; Phong et al. additively-HE deep learning [32]; FheFL (Rahulamathavan et al.) [33]; FedML-HE (Jin et al., selective encryption that sacrifices fully-encrypted aggregation) [20]; Sebert et al. FHE+DP [37]; Hu et al. segmented gossip (decentralized inspiration for CMS) [14]; Flower FL framework [22]; Pyfhel / Microsoft SEAL [18, 35]. Attacks compared against: Geiping et al. GIA [10] and Wei et al. malicious-client gradient inversion [40].

Code and artifacts

Not released — no repository URL is given in the paper; license not stated.

Extra diagrams (optional)

Threat model

flowchart LR
    KD[Key Distributor] -- K_pub --> C[Honest client c_s]
    KD -- K_pub --> A[Malicious client]
    KD -- K_priv after agg --> C
    KD -- K_priv after agg --> A
    C -- Enc subset w --> S[Server honest-but-curious]
    A -- Enc poisoned subset --> S
    S -- Enc global W --> C
    S -- Enc global W --> A
    A -- isolated g_a --> A2[GIA reconstruct d_j]

Server: honest-but-curious, sees only ciphertexts (single-key FHE provably safe). Malicious clients: poison their submitted segments to isolate target-class gradients in the decrypted global update; CMS limits how much of the gradient any one update can influence and how much they can observe [§2.3, §5].

Federated round

sequenceDiagram
    participant KD as Key Distributor
    participant C as Clients (c of C)
    participant S as Server
    KD->>C: K_pub
    S->>C: Request row R_i (which matrices to send)
    C->>C: Local train then encrypt subset w_i,j
    C->>S: Enc(w_i,j), t_i,j
    S->>S: HE weighted avg per j (Algorithm 3)
    S->>KD: Aggregation complete
    KD->>C: K_priv
    S->>C: Enc(W)
    C->>C: Decrypt -> global model

Activation approximation

N/A. Activations are not under FHE in BlindFL — they execute in plaintext during local client training; only the FedAvg weighted sum is homomorphic [§4.2].

Open questions