First-hand information for everyone
A new software library called Zeppelin demonstrates that modern microcontrollers with vector acceleration can perform both encryption and decryption using a fully homomorphic-friendly integer scheme, potentially changing how privacy is handled in small Internet-of-Things (IoT) devices. The work appears on arXiv as “Zeppelin: Client-Side BFV Encryption and Decryption for Helium-Powered Microcontrollers” (arXiv:2610.08301v1).
Why this matters
Homomorphic encryption (HE) lets an untrusted server compute on encrypted data without learning the underlying values. That property is attractive for privacy-preserving sensing and analytics: a tiny sensor could encrypt readings and send ciphertexts to the cloud, which performs analytics while never seeing raw data. Until now, HE has mostly been too expensive in memory and CPU for microcontroller-class devices. Prior efforts made strides—for example, SEAL-Embedded enabled CKKS-based HE on some MCUs—but left key gaps: they used scalar arithmetic even when hardware offered vector instructions, they often left decryption to more powerful machines so the device could not consume results, and they did not explore BFV, an integer-based HE scheme that decrypts exactly (useful when approximate arithmetic is unacceptable).
What Zeppelin does
Zeppelin fills those gaps in three main ways. First, it is the first HE library to target an embedded vector instruction set (ARM’s Helium, the M‑Profile Vector Extension) and to vectorize the number-theoretic transform (NTT), which is the main computational bottleneck in many HE schemes. Second, it supports both encryption and decryption on the device, so a constrained client can both send encrypted data and later decrypt computed results returned by the server. Third, it implements BFV on microcontroller-class hardware—BFV uses integer encoding and yields exact decryption, which can be preferable for some sensor-data and audit applications.
Implementation and performance highlights
The authors run Zeppelin on an STM32N6 MCU with an ARM Cortex-M55 core that supports Helium. Using a seeded symmetric key setup and parameters that meet 128-bit security per standard HE recommendations, Zeppelin encodes and encrypts a batch of 4,096 packed integer values in about 4.76 ms and later decrypts and decodes such a result in about 5.38 ms. The library uses under 500 KB of RAM in these experiments. The vectorized NTT engine in Zeppelin is roughly 2.7× faster than an equivalent scalar implementation on the same core.
Interoperability and security considerations
To keep heavy homomorphic computation off the device, Zeppelin provides a server-side adapter that converts its ciphertext format into one compatible with Microsoft SEAL. That lets the small device handle the client-facing crypto (encrypting and later decrypting) while a cloud server—running mature HE tooling—does the computationally expensive homomorphic operations.
The paper also addresses implementation-level issues: the decryption routine is designed to avoid large-integer arithmetic on the device and to reduce timing leakage of the secret key. Those are important practical concerns, because side channels and inefficient big-integer code are common pitfalls when porting crypto to constrained hardware. Still, the usual caveats apply: further peer review, independent implementation testing, and side-channel analysis remain important before deployment in high-risk settings.
Limitations and outlook
Zeppelin’s results are promising but should be seen in context. The gains rely on hardware support for vector instructions (ARM Helium / Cortex‑M55), so many older or simpler MCUs will not benefit. BFV’s integer arithmetic and exact decryption are strengths for certain workloads, but other HE schemes (like CKKS) are better suited to approximate real-valued computation such as encrypted neural-network inference. And while moving encryption and decryption to the client reduces trust placed on servers, it does not eliminate system-level challenges—key management, firmware updates, energy use, and the server-side cost of homomorphic computation remain significant practical issues.
Overall, Zeppelin demonstrates that with careful engineering and modern embedded vector hardware, client-side HE—encryption and decryption—can be made practical on some microcontrollers. For privacy-minded IoT applications that can adopt Helium-capable chips and integer-friendly workloads, this work lowers a barrier to running private analytics without exposing raw sensor data to the cloud. Further validation, broader hardware support, and integration work will determine how widely these ideas can be adopted in the field.