TL;DR

Hong et al. construct the first fully encrypted, non-interactive functional-encryption (FE) protocol for ML inference: a new “LinEnc-QFE” quadratic FE scheme whose encryption algorithm is a linear function of the message, enabling iterative Enc ∘ f composition so that intermediate layers stay ciphertext and the client never has to come back online [§1.1, §3.1]. They instantiate a 2-layer quadratic neural network on Iris and Breast Cancer and prove security against malicious adversaries [§4, §5.3].

Problem and motivation

Existing FHE- and MPC-based PPML protocols either require the client to be online during computation (MPC) or require the client to decrypt the final result (FHE), making applications such as server-side spam filtering impractical [§1]. FE-based PPML avoids interaction but prior FE schemes only support inner-product or quadratic functions, so prior FE-PPML works are “partially encrypted” — the first layer is encrypted, later layers run in cleartext. Carpov et al. [7] showed that such cleartext intermediates leak input information [§1]. The threat model is malicious adversaries: the evaluator and other clients may deviate arbitrarily and collude, yet must learn nothing beyond F(x₀) [§4.1, Definition 1].

Key contributions

FHE setup

ML setup

Datasets

Dataset Task Size (train/test) Modality Notes
Iris (UCI) 3-class classification Not reported Tabular ℓ = 4 features, scaled by S = 2³⁰; cross-entropy training loss [§5.3]
Breast Cancer (UCI) 2-class classification Not reported Tabular ℓ = 9 features, scaled by S = 2³⁰ [§5.3]
Synthetic toy Benchmark of two-layer protocol N/A Random vectors Z_N^ℓ for ℓ = 1..6 Used in Table 3 micro-benchmarks [§5.1]

Pipeline diagram

Non-interactive flow: the client encrypts once and goes offline; the evaluator obtains the final plaintext result without contacting the client again.

flowchart LR
    subgraph KD [Key Distributor]
        K1[Sample pk, msk] --> K2[Sample γ, h_i]
        K2 --> K3[Issue fk_Enc∘f_i, fk_f_E]
    end
    subgraph Client
        C1[Input x] --> C2[Encrypt γ(x) with pkIPFE]
    end
    subgraph Evaluator
        E1[Receive ct_γ(x)] --> E2[Dec fk_1: ct of h_1∘f_1(x)]
        E2 --> E3[Dec fk_2: ct of h_2∘f_2∘f_1(x)]
        E3 --> E4[Dec fk_E: plaintext F(x)]
    end
    K1 -. pk, γ .-> C1
    K3 -. functional keys .-> E1
    C2 -. ct_γ(x) .-> E1
    E4 --> O([Inference result])

Pipeline steps (text)

  1. The Key Distributor runs Setup → (pk, msk) and samples random invertible linear maps (γ, γ⁻¹) and (h_i, h_i⁻¹) per layer; ships pk and γ to the client [§1.2, step 1].
  2. The client computes ct_{γ(x)} ← Enc(pk, γ(x)) using pkIPFE and sends a single ciphertext to the evaluator, then goes offline [§1.2, step 2; §4].
  3. The evaluator submits the trained model f_1, …, f_E (quadratic functions) to the Key Distributor [§1.2, step 3].
  4. The Key Distributor produces functional keys fk_i ← KeyGen(msk, Enc ∘ F_i) for intermediate layers (with F_i = h_i ∘ f_i ∘ h_{i-1}⁻¹) and fk_E ← KeyGen(msk, f_E ∘ h_{E-1}⁻¹) for the output layer; sends keys to the evaluator [§1.2, step 4].
  5. The evaluator iteratively decrypts: ct_{h_i ∘ f_i ∘ ⋯ ∘ f_1(x)} ← Dec(fk_i, ct_{prev}), each output remaining a LinEnc-QFE ciphertext [§1.2, step 5; §3.4].
  6. Final-layer decryption with fk_E returns f_E ∘ ⋯ ∘ f_1(x) in plaintext; the client is never contacted again [§1.2, step 5; §6].

Architecture diagram

The 2-layer Quadratic Neural Network the paper actually evaluates (Iris uses ℓ=4, d=3; Breast Cancer uses ℓ=9, d=2; both share hidden width u=4) [§5.3].

flowchart LR
    I([Input x ∈ R^ℓ]) --> L1[Linear W_h·x + β_h]
    L1 --> A1[Square activation]
    A1 --> L2[Linear W_o·a* + β_o]
    L2 --> A2[Square activation]
    A2 --> O([Output b ∈ R^d])

Results

Reported on Intel Xeon Silver 4208 @ 2.10 GHz, 30 GB RAM, Linux [§5]. Per-input inference times (one sample) and the per-party costs are below [Table 5, p. 21]. The evaluator’s Dec step is the per-inference latency in plaintext-output terms; KeyGen is a one-time per-model cost (paid by the Key Distributor).

Metric This paper Baseline Hardware
Inference accuracy error vs plaintext (Iris, Breast Cancer) < 10⁻⁷ (real-number error after S=2³⁰ integer scaling) [§5.3] Plaintext QNN Xeon Silver 4208
Per-inference Dec time (Iris, ℓ=4, u=4, d=3) 1.11 h ≈ 3996 s [Table 5] — Xeon Silver 4208, 30 GB RAM
Per-inference Dec time (Breast Cancer, ℓ=9, u=4, d=2) 3.32 h ≈ 11952 s [Table 5] — Xeon Silver 4208, 30 GB RAM
Per-inference Enc time (client, Iris / Breast) 0.93 s / 1.13 s [Table 5] — Xeon Silver 4208
KeyGen (one-time per model, Iris / Breast) 1.05 h / 3.61 h [Table 5] — Xeon Silver 4208
Setup (Iris / Breast) 1.47 s / 4.92 s [Table 5] — Xeon Silver 4208
Toy two-layer protocol Dec @ ℓ=6 4.02 h [Table 3] — Xeon Silver 4208
Group exponentiation cost E ≈ 321 ms / op [§5.2] Pairing-based [37]: E₁=E₂=16 ms, P=22 ms (Charm) Xeon Silver 4208
Classification accuracy Not reported — —

The headline accuracy figure (classification accuracy of the QNN) is not reported; the paper only reports that the encrypted inference output matches the plaintext QNN’s output to within 10⁻⁷ [§5.3]. The single_inference_seconds in the front matter records the Breast Cancer Dec time (3.32 h).

Limitations and assumptions

Code and artifacts

Repository: https://github.com/swanhong/fully-encrypted-ml/ [§1.1, §5.1]. License: Not reported.

Extra diagrams (optional)

Threat model

Three parties; security holds against a malicious adversary that may corrupt the evaluator and the non-honest clients {C_j}_{j≥1}. The honest client C_0 is the input owner [§4.1].

flowchart LR
    KD[Key Distributor - trusted] -- pk, γ --> C0[Honest client C₀]
    KD -- fk_Enc∘f_i, fk_f_E --> E[Evaluator - possibly malicious]
    C0 -- ct_γ&#40;x₀&#41; --> E
    Cj[Other clients C_j - possibly malicious + colluding] -- ct_x_j --> E
    E --> R([F&#40;x₀&#41; in plaintext])

Open questions