TL;DR

The paper presents the first end-to-end Hybrid Homomorphic Encryption (HHE) framework for Federated Learning, pairing the PASTA symmetric stream cipher with the BFV FHE scheme on top of the Flower FL framework, achieving 97.6% accuracy on IID MNIST while shrinking client upload bandwidth by over 2000x compared to a pure-BFV baseline [Abstract][§6.3].

Problem and motivation

Federated Learning ostensibly preserves privacy by keeping raw data on-device, but model updates leak information via gradient inversion, membership inference, and property inference attacks [§1][§2.1]. Pure FHE protects updates but suffers from ciphertext expansion and large algebraic depth, making it prohibitive for resource-constrained IoT clients [§1]. The authors target cross-device FL with an honest-but-curious server, fully honest clients, no collusion, and a trusted setup phase via a Third-Party Authority (TPA) [§4.2].

Key contributions

FHE setup

ML setup

Datasets

Dataset Task Size (train/test) Modality Notes
MNIST 10-class digit classification 60000 train / 10000 test 28x28 grayscale images IID partitioned across 12 clients via Flower’s IidPartitioner; per-client 80/20 train/test split; 20% of local training set reserved for early-stopping validation [§6.1]

Pipeline diagram

flowchart LR
    subgraph TPA
        T[Generate HE_pk, HE_sk, HE_eval, sk_i]
    end
    subgraph Client_i
        L[Local train wi] --> Q[Quantize int8 to uint64]
        Q --> E1[PASTA encrypt wi with sk_i]
        E1 --> E2[BFV encrypt sk_i with HE_pk]
    end
    subgraph Server
        H[HESD chunk by chunk] --> A[FedAvg sum weighted by nk]
    end
    subgraph Client_dec [Client_i]
        D[BFV decrypt with HE_sk] --> AVG[Divide by n, dequantize]
    end
    T -. HE_pk, HE_sk, sk_i .-> L
    T -. HE_pk, HE_eval .-> H
    E1 -. wSKE chunks .-> H
    E2 -. skHE .-> H
    A -. enc global weights .-> D
    AVG --> L

Pipeline steps (text)

  1. Setup: TPA generates (HE_pk, HE_sk, HE_eval) and a unique symmetric key sk_i for each client; sends (HE_pk, HE_eval) to the server and (HE_pk, HE_sk, sk_i) to each client; server initializes the global model weights [§4.1].
  2. Clients receive global weights (plaintext in round 1, BFV-encrypted in later rounds and decrypted with HE_sk) [§4.1].
  3. Each client trains its local model in plaintext using LeakyReLU activations [§6.1].
  4. Client quantizes weights from float32 to int8 (scale = 127/α, α = 5) and converts to uint64 for PASTA [Algorithm 2].
  5. Client encrypts the quantized weight vector chunk-by-chunk with PASTA (sk_i), producing w_SKE; encrypts sk_i with HE_pk producing sk_HE; sends (w_SKE, sk_HE, n_i) to the server [§4.1, Algorithm 2].
  6. Server performs chunk-based HESD: homomorphically evaluates PASTA decryption on each w_SKE chunk using sk_HE, yielding BFV ciphertexts [Algorithm 1].
  7. Server runs FedAvg: multiplies each BFV-encrypted weight vector by n_k and homomorphically sums across clients; division by n is deferred to clients [§5].
  8. Server sends the aggregated BFV ciphertexts to the next round’s clients [§4.1].
  9. Clients decrypt with HE_sk, convert uint64 back to int64 (adjusting for modulus wrap), divide by n in float32, and dequantize by dividing by scale factor [Algorithm 3].
  10. Clients evaluate locally on the test set and return accuracy/loss/sample count to the server for the Server Evaluation phase [§4.1].

Architecture diagram

flowchart LR
    I([Input 1x28x28]) --> C1[Conv + LeakyReLU + BN]
    C1 --> P1[MaxPool]
    P1 --> C2[Conv + LeakyReLU + BN]
    C2 --> P2[MaxPool]
    P2 --> F[Flatten]
    F --> DR[Dropout]
    DR --> FC[Dense 10]
    FC --> O([Softmax / argmax])

Results

Metric This paper (PASTA+BFV) Plaintext FL Pure BFV Hardware
Accuracy 97.6% (text) / 97.39% (Table 2) 98.93% / 99.00% 98.04% / 98.21% Google Colab T4 High-RAM (NVIDIA T4 GPU, Intel Xeon @ 2.20GHz, 51GB RAM) [§6.1, §6.3, Table 2]
Loss 0.0962 0.0360 0.0702 Same [Table 2]
Precision / Recall / F1 97.50 / 97.39 / 97.39 (%) 99.00 / 99.00 / 99.00 98.23 / 98.21 / 98.21 Same [Table 2]
Client upload cost ~2000x lower than pure BFV N/A 2000x higher than HHE Same [§6.3, Fig. 6a]
Client encryption time 0.32867 s N/A 3.18009 s Same [Fig. 7a]
Client decryption time 0.42206 s N/A 2.90076 s Same [Fig. 7a]
Client training time 10.70805 s 10.70805 s 10.70805 s Same [Fig. 7a]
Client total runtime 12.53394 s N/A 17.86406 s (~1.4x slower) Same [Fig. 7a]
Server aggregation (HESD) per client (8000 params) 1451 s N/A N/A (BFV server agg only 0.0929 s) Same; HESD ~1.7x faster on local Intel Core i7-11370H, 16GB RAM [§6.3, Fig. 7b]
Server total runtime per round (4 clients) 5804.2174 s (HESD per round ~1.6122 h) N/A 0.0929 s Same; ~62478x slower than pure BFV; ~15621x average per-client overhead [§6.3, Fig. 7b, §7]

Limitations and assumptions

Code and artifacts

Not released. The prototype builds on the ISEC TU Graz open-source hybrid-HE-framework (https://github.com/isec-tugraz/hybrid-HE-framework), Microsoft SEAL (BFV), TenSEAL, Flower, and pybind11; no project-specific repository URL is reported in the paper [§5, §6.1].

Extra diagrams (optional)

Threat model

flowchart LR
    TPA[TPA trusted] -- HE_pk, HE_sk, sk_i --> C[Client honest]
    TPA -- HE_pk, HE_eval --> S[Server honest-but-curious]
    C -- wSKE + skHE --> S
    S -- enc aggregated weights --> C
    EXT[External adversary] -. eavesdrop .- C

Federated round

sequenceDiagram
    participant C as Clients
    participant S as Server
    C->>C: Local train wi (plaintext)
    C->>C: Quantize int8 then uint64
    C->>C: PASTA enc wi with sk_i, BFV enc sk_i
    C->>S: wSKE, skHE, n_i
    S->>S: HESD chunk by chunk per client
    S->>S: FedAvg homomorphic weighted sum
    S->>C: enc aggregated weights
    C->>C: BFV decrypt with HE_sk
    C->>C: Divide by n, dequantize

Open questions