💻 computer science

An Adaptive Resource-Aware MK-CKKS Framework with Linear- Complexity Multi-Key Aggregation for Privacy-Preserving Federated Learning in Resource-Constrained IoT Environments

This paper presents an adaptive resource-aware MK-CKKS framework for privacy-preserving federated learning in IoT that achieves linear-complexity multi-key aggregation and significant performance gains through real-world experiments on MNIST and CIFAR-10, while transparently acknowledging that independent-key construction and physical hardware validation remain future work.

Original authors: Nasir Ahmad Jalali, Hongsong Chen

Published 2026-08-10

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Nasir Ahmad Jalali, Hongsong Chen

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a world where your smartwatch, your neighbor's thermostat, and your car's navigation system all want to learn together to make better predictions, but they are terrified of sharing their secrets. This is the heart of Federated Learning, a clever way for computers to collaborate on a team project without ever handing over their private notebooks. Instead of sending their data to a central boss, they only send the "lessons learned" (mathematical updates) back and forth.

But there's a catch: even these lessons can accidentally reveal private details, like what you typed or where you drove. To stop this, scientists use a magical trick called Homomorphic Encryption. Think of it as a locked glass box. You can put a piece of paper inside, lock it, and then perform math on the box itself. The box gets heavier or changes shape, but the paper inside remains hidden. When you finally unlock it, the result is exactly what you would have gotten if you had done the math on the paper directly. However, these "locked boxes" are heavy, slow to carry, and if you have a hundred friends trying to combine their boxes, the process of merging them can become a logistical nightmare that crashes the system.

This is the puzzle tackled by Nasir Ahmad Jalali and Hongsong Chen in their new research. They asked: "How can we make this secret-sharing math fast and light enough for tiny, battery-powered devices like IoT sensors, without breaking the lock?"

The Problem: The Heavy Backpack

In the past, trying to combine encrypted updates from many different devices was like trying to merge a hundred different languages into one conversation. Every time two devices wanted to share their "locked boxes," they had to perform a complex translation step called key-switching. If you had 20 devices, this translation had to happen hundreds of times. If you had 200 devices, the number of translations exploded, growing so fast (quadratically) that the system would grind to a halt. It was like trying to introduce every person in a stadium to every other person individually before they could sing a song together.

Furthermore, standard encryption settings were designed for massive cloud servers, not for small, energy-hungry devices. Using these heavy settings on a tiny sensor was like trying to power a flashlight with a car battery—it worked, but it drained the battery instantly and was way too bulky.

The Solution: A Smart Assembly Line

The authors propose a new framework that acts like a smart assembly line for these encrypted messages. Their big breakthrough is a new way to handle the "translation" step. Instead of making every device talk to every other device, they introduce a Reference Domain.

Imagine a group of spies who all need to send secret messages to a central hub. In the old way, Spy A would have to translate their message for Spy B, then for Spy C, and so on. In the new method, every spy translates their message just once into a common "hub language" (the reference domain). Once everyone is speaking the same language, they can simply dump their messages into a single pile. This changes the workload from a chaotic, quadratic mess (where doubling the spies quadruples the work) to a simple, linear list (where doubling the spies just doubles the work).

They also added a "resource-aware" brain to the system. Before sending a message, the system checks the device's battery and speed. If a device is weak, it uses a lighter, faster encryption setting. If it's strong, it uses a heavier, more secure one. This ensures no device gets overwhelmed.

What They Actually Found

The researchers didn't just run these ideas on a computer simulation; they built the system and tested it for real. They trained models on two famous image datasets, MNIST (handwritten digits) and CIFAR-10 (color photos of animals and cars), using a network of simulated devices.

Here is what their real-world tests showed:

Speed: When they increased the number of devices from 20 to 200, their new method was 9.4 to 100.6 times faster at combining the messages than the old, clumsy way.
Efficiency: They managed to cut the amount of data sent over the network by about 39% to 41% and reduced the time it took to finish a round of training by 66% to 68%.
Accuracy: The most important part? The system learned just as well as the unencrypted version. On the handwritten digit test, it achieved 94.98% accuracy, and on the color photo test, it hit 46.97%. The "magic box" didn't break the math; it just hid it better.
Packing Power: By stuffing multiple pieces of data into a single encrypted "box" (a technique called packing), they reduced the size of the messages by a staggering 3,900 to 4,060 times compared to sending them one by one.

The Honest Truth

While the results are impressive, the authors are very careful to be honest about what they haven't done yet. They admit that they haven't tested this on actual physical devices like a Raspberry Pi or a real smartwatch; their tests were run on a standard computer server. They also note that while they proved the math of their new "translation" method works perfectly for up to 200 devices, they haven't yet built a public library that uses the exact "independent key" setup for every single device in the real world. That is the next step.

Why It Matters

This paper shows that we don't have to choose between privacy and performance. By rethinking how encrypted devices talk to each other, we can build a future where your smart devices can learn together to make our lives better, without ever needing to trust a central boss with our private data. It turns a heavy, slow, and expensive process into something light, fast, and scalable, paving the way for truly private artificial intelligence in our everyday gadgets.

Technical Summary: An Adaptive Resource-Aware MK-CKKS Framework for Privacy-Preserving Federated Learning in Resource-Constrained IoT Environments

1. Problem Statement

The proliferation of IoT devices has enabled distributed machine learning via Federated Learning (FL), yet resource-constrained devices face significant challenges in deploying privacy-preserving protocols. While Homomorphic Encryption (HE), specifically the CKKS scheme, allows computation on encrypted data, standard configurations are tuned for cloud-scale workloads, resulting in prohibitive ciphertext sizes and computational overhead for IoT devices.

The problem is exacerbated in multi-key settings where clients belong to independent trust domains and cannot share a single encryption key. Existing Multi-Key Homomorphic Encryption (MKHE) approaches introduce a key-switching cost that scales quadratically ( $O(K^2)$ ) with the number of clients ( $K$ ) due to pairwise ciphertext alignment. Furthermore, prior research often addresses resource adaptation (single-key) or multi-key aggregation separately, leaving a gap in frameworks that jointly optimize computation, communication, and energy costs while maintaining scalability and 128-bit security in heterogeneous IoT environments.

2. Methodology

The paper proposes an Adaptive Resource-Aware MK-CKKS Framework that integrates three core mechanisms under a unified optimization model:

Reference-Domain Key-Switching Protocol: To address the $O(K^2)$ scalability bottleneck, the framework introduces a protocol where all clients map their ciphertexts to a single reference evaluation domain ( $pk_s$ ) held by the server. Instead of pairwise alignment, each client performs exactly one key-switching operation ( $c_k \leftarrow KS(c_k, TK_{k \to s})$ ). This reduces the total key-switching complexity from $O(K^2)$ to $O(K)$ .
Joint Multi-Objective Optimization Model: The framework formulates an optimization problem to select CKKS parameters (polynomial modulus degree $N$ $N$ , ciphertext modulus chain $Q$ $Q$ , scaling factor $\Delta$ $Δ$ , packing density $\rho$ $ρ$ , and key-switching frequency $f_{ks}$ $f_{k s}$ ). The objective minimizes a weighted sum of computational, communication, and energy costs, subject to explicit constraints:
- Security: Must meet a 128-bit security level (RLWE hardness).
- Accuracy: Must satisfy a minimum accuracy threshold.
- Resources: Must adhere to device-specific limits on CPU, memory, and bandwidth.
Adaptive Strategies:
- Parameter Adaptation: Devices are classified by resource tiers (low/medium/high), allowing the selection of smaller polynomial degrees ( $N$ ) for constrained devices without compromising security.
- Ciphertext Packing: Utilizing CKKS's SIMD capabilities to pack multiple model parameters into a single ciphertext, drastically reducing communication volume.
- Computation Partitioning: Offloading heavy operations (batch processing, multi-key transformations) to edge/server components while keeping local training lightweight.

3. Key Contributions

The paper claims four primary contributions, validated through real-world execution rather than simulation:

Linear-Complexity Key-Switching: Formalization and validation of a reference-domain protocol reducing multi-key aggregation complexity from $O(K^2)$ to $O(K)$ . This claim is validated by executing real re-linearization-proxy operations for up to $K=200$ clients, demonstrating speedups of 9.4× to 100.6× over standard pairwise alignment.
Joint Resource-Aware Optimization: A novel optimization model (Equation 9) that simultaneously balances computation, communication, and energy costs under a fixed 128-bit security constraint, differing from prior work that optimized single dimensions or operated in single-key settings.
Rigorous Complexity and Security Analysis: Explicit claims regarding the asymptotic improvement in key-switching and a design-level argument (Proposition 2) that adaptive parameterization preserves security guarantees under an honest-but-curious server assumption, provided the parameter search is restricted to sets meeting the security floor.
Empirical Validation via Real Experiments: Unlike prior simulation-based studies, this work provides:
- Federated training on real MNIST and CIFAR-10 datasets with non-IID partitioning.
- Direct execution of cryptographic operations (TenSEAL/OpenFHE) rather than projected formulas.
- Verification of multi-party threshold-CKKS correctness for up to 32 parties.
- Real measurements of communication reduction and latency.

4. Experimental Results

The framework was evaluated on real datasets (MNIST, CIFAR-10) with $K=20$ clients for accuracy and up to $K=200$ for scalability, using a compact single-hidden-layer MLP.

Accuracy: The proposed framework achieved 94.98% accuracy on MNIST and 46.97% on CIFAR-10 (mean over 3 seeds). Crucially, the encrypted framework's accuracy was numerically identical to the plaintext FedAvg baseline and the fixed-parameter CKKS-FL baseline, confirming that the encryption and aggregation layers introduce no measurable degradation in learning performance.
Efficiency Gains:
- Communication: Achieved a 39–41% reduction in communication overhead compared to conventional fixed-parameter CKKS-FL.
- Latency: Achieved a 66–68% reduction in aggregation latency across the $K=20$ to $200$ range.
- Packing Impact: Ciphertext packing demonstrated a 3,900×–4,060× reduction in transmitted bytes compared to unpacked transmission.
Scalability: The ablation study confirmed that removing the reference-domain key-switching optimization increased latency by approximately 81%, validating the structural impact of the $O(K)$ approach.

5. Significance and Limitations

Significance:
The paper positions its contribution as closing the specific gap between multi-key aggregation and resource-aware optimization. It demonstrates that it is possible to achieve linear scalability in multi-key FL aggregation and joint resource optimization without sacrificing security (128-bit) or accuracy. The results are significant because they are derived from genuine, executed measurements of cryptographic primitives and full FL training loops, rather than theoretical projections.

Modest Claims and Limitations:
The authors explicitly state the following limitations and scope boundaries:

Independent-Key Validation: While the $O(K)$ complexity structure is validated via real execution, the specific correctness of the per-client independent-key MK-CKKS construction (e.g., Chen–Dai–Kim–Song) could not be empirically verified because no public library implementing this exact construction was available. Instead, the framework relies on a design-level security argument and a re-verified threshold-CKKS experiment (OpenFHE) for correctness.
Hardware Constraints: Experiments were conducted on a single-vCPU cloud environment, not physical IoT hardware (e.g., Raspberry Pi). Consequently, energy figures are modeled estimates based on time and constant power draw, not direct hardware measurements.
Model Scale: The use of a compact MLP (rather than CNNs) was a deliberate choice to keep encryption and key-switching experiments tractable within the compute budget. The authors acknowledge that absolute accuracy on CIFAR-10 (46.97%) is lower than CNN-based literature benchmarks.
Threat Model: The framework addresses confidentiality against honest-but-curious servers and eavesdroppers. Defense against malicious/Byzantine clients and physical device compromise is out of scope.

In conclusion, the paper provides a validated framework that reduces the computational and communication barriers to privacy-preserving FL in IoT, specifically targeting the scalability bottleneck of multi-key aggregation, while transparently acknowledging the remaining gaps in independent-key library implementation and physical hardware validation.