💻 computer science

Light-Weight Cryptographic Heartbeat Protocol In Robotic Swarms

This paper presents a lightweight cryptographic heartbeat protocol for robotic swarms that ensures message authentication and integrity in distributed edge-computing systems using only clock synchronization and hash functions, while demonstrating low latency, minimal storage requirements, and robustness against network anomalies on Raspberry Pi 5 hardware.

Original authors: Faris Alhamed, Mohamed Mtiri, Francesco Paolucci, Filippo Cugini, Alex Shafarenko

Published 2026-08-03

📖 3 min read☕ Coffee break read

CC BY 4.0

Original authors: Faris Alhamed, Mohamed Mtiri, Francesco Paolucci, Filippo Cugini, Alex Shafarenko

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 bustling city where millions of tiny, autonomous robots zip around, talking to each other to build things, move cargo, or fix problems. In this high-tech world, every robot needs to constantly shout, "I'm here! I'm working!" to its neighbors. This is called a "heartbeat." But just like in a crowded room, bad actors might try to sneak in, pretend to be a robot, or repeat old messages to cause chaos. To stop this, the robots need a secret handshake that proves who they are and that their message hasn't been tampered with. Usually, this handshake is like a heavy, complicated lock that takes a lot of energy to open and close—too heavy for a tiny robot with a small battery. This is the world of cryptography (the science of secret codes) and swarm robotics (groups of robots working together). The big question scientists are asking is: How can we give these tiny robots a super-strong, unbreakable secret handshake that doesn't drain their batteries or slow them down?

This research paper introduces a clever, lightweight solution for exactly that problem. The authors, working with robots in a "Smart Factory" setting, have designed a new way for robots to send their heartbeats securely without needing heavy computer power. Instead of using the traditional, heavy locks (like RSA or ED25519 digital signatures), they use a method based on a hash chain. Think of this chain like a magical, one-way staircase. You can easily walk down the stairs by stepping on a hash function (a mathematical recipe that scrambles data), but you cannot walk back up. The robot starts at the top of the stairs with a secret key and walks down one step for every heartbeat it sends. The receiver (the robot's boss) only knows the very bottom step. When a message arrives, the boss checks if the robot's current step matches the math of the previous step. If it does, the message is real. If a message is lost in the shuffle, the boss can just "skip" the missing steps by doing the math forward until they catch up, ensuring the chain never breaks.

The paper demonstrates that this system is incredibly efficient. In tests using Raspberry Pi 5 computers (which act as the robots), the system managed to initialize in less than 900 ms and required as little as 1 MB of storage space on the sender's side. The receiver needed almost no storage at all. The researchers found that this method could handle messy network conditions, including lost messages, duplicates, and messages arriving out of order, all while keeping the robots safe from replay attacks (where a hacker records a valid message and plays it back later). They also confirmed that the system works well even when the robots' clocks aren't perfectly synced, as long as the time difference stays under 50 ms. By swapping heavy public-key cryptography for this lighter, hash-based approach, the paper suggests that we can secure massive swarms of robots without bogging them down, making future factories and autonomous systems both safer and smarter.

Technical Summary: Light-Weight Cryptographic Heartbeat Protocol in Robotic Swarms

Problem Statement

Modern industrial environments, particularly within the Industry 4.0 paradigm, increasingly rely on autonomous swarms of mobile robots and IoT devices in Smart Factories. These systems require continuous monitoring of device "liveness" through periodic heartbeat messages to facilitate fault detection, orchestration, and security monitoring. However, existing solutions face significant challenges in resource-constrained edge environments:

Computational Overhead: Traditional public-key cryptography (e.g., RSA, ED25519) imposes prohibitive computational, memory, and energy costs due to big-integer arithmetic and modular exponentiation, which can drain IoT batteries rapidly.
Quantum Vulnerability: Many classical public-key primitives are susceptible to future quantum attacks, posing long-term security risks for persistent deployments.
Network Anomalies: Distributed edge networks are prone to message loss, delays, duplications, and reordering, which can disrupt heartbeat validation and lead to false positives in fault detection.
Security Requirements: The system must guarantee message integrity, sender authentication, and non-repudiation while resisting replay and Denial-of-Service (DoS) attacks, without necessarily requiring full encryption.

Methodology

The authors propose a lightweight cryptographic heartbeat protocol designed for distributed edge-computing systems, specifically tailored for robotic swarms. The solution integrates time-synchronized heartbeat generation with hash-chain-based integrity validation.

Core Cryptographic Mechanisms

The protocol relies on the Winternitz One-Time Signature (WOTS) scheme based on hash-chains and the Guy Fawkes Protocol, avoiding public-key cryptography entirely.

Hash Chain Generation: Each Smart Node (sender) generates a random private key $x_0$ . It then computes a forward-secure hash chain of length $n$ where $x_j = H(x_{j-1})$ . The final value $x_n$ is shared with the receiver (Swarm Coordinator) as a public key via a secure initial channel (e.g., offline or NFC).
Message Construction: For each heartbeat interval $i$ $i$ , the node constructs a message $M_i$ $M_{i}$ containing:
- Headers ( $q_i$ ): Including a synchronized timestamp $T_i$ and the current hash-chain value $x_{n-i}$ .
- Payload ( $p_i$ ): System health and liveness data.
- Authenticator ( $y_i$ ): An HMAC calculated as $HMAC(x_{n-i-1}, q_i \parallel p_i)$ .
Verification Process: The receiver validates incoming messages by:
- Checking the hash-chain progression: Verifying that $H(x_{n-i})$ matches the previously stored value (or a forward-hashed value if packets were lost).
- Verifying the HMAC using the derived chain value.
- Ensuring strict temporal ordering based on synchronized clocks.

System Architecture and Assumptions

Clock Synchronization: The protocol assumes the sender and receiver clocks are synchronized (e.g., via NTP over WiFi) with an accuracy better than half the heartbeat interval ( $\epsilon \lesssim \tau/2$ ). This allows the receiver to infer sequence numbers from timestamps without explicit sequence counters in the payload.
Loss Tolerance: A "forward hashing" mechanism allows the receiver to skip missing chain elements. If heartbeat $i$ is lost but $i+k$ arrives, the receiver computes $H^{(k)}(x_{n-(i+k)})$ to verify the chain integrity, marking intermediate messages as lost without breaking the cryptographic chain.
Hardware Implementation: The study utilizes Raspberry Pi 5 devices for Smart Nodes and Coordinators, leveraging hardware acceleration for specific hash functions.

Key Contributions

The paper outlines four primary contributions:

Post-Quantum Secure Design: A heartbeat protocol based on Winternitz hash-chain progression and HMAC authentication, avoiding vulnerable public-key primitives.
Strict Ordering and Replay Resistance: The system ensures strict message ordering and detects replay attacks without relying on public-key cryptography, using time-based sequence inference.
Loss-Tolerant Verification: A receiver-side mechanism using forward hashing enables scalable operation in lossy networks, allowing validation of subsequent heartbeats even when gaps exist in the transmission stream.
Resource Efficiency: The protocol demonstrates minimal computational cost, suitable for highly constrained edge nodes, by converting heavy computations into manageable memory requirements.

Experimental Results and Validation

The protocol was evaluated in a testbed consisting of Raspberry Pi 5 devices acting as Swarm Nodes and a Coordinator, connected via a Dell Edge Gateway 5200 over WiFi.

Clock Synchronization: Using NTP over WiFi, the maximum observed clock drift was approximately 44 ms under normal conditions (RSSI > -70 dBm, <90% load). This supports heartbeat intervals ( $\tau$ ) greater than 100 ms.
Algorithm Performance: On Raspberry Pi 5 hardware:
- SHA-256 was the most efficient for generating hash chains (approx. 1.04 million iterations/sec) due to hardware acceleration.
- Keyed BLAKE3 offered the best performance for HMAC generation (approx. 439,000 iterations/sec).
- ED25519 was significantly slower (approx. 13,886 iterations/sec), highlighting the efficiency of the proposed hash-based approach.
Initialization and Storage:
- Initialization Time: The total initialization time was measured at no more than 900 ms.
- Storage: The sender requires as little as 1 MB of storage space (using a "gearing" strategy to trade storage for re-computation), while the receiver has negligible storage requirements, needing to store only the current and previous chain points.
Robustness: The system successfully detected and discarded duplicate messages, identified out-of-order arrivals, and recovered from lost messages (e.g., messages 4 and 7 in the test sequence) using forward hashing, maintaining chain integrity throughout.

Significance and Claims

The paper claims that the proposed protocol successfully addresses the trade-off between security and resource constraints in autonomous robotic swarms. By eliminating public-key cryptography and leveraging hash-chains with forward hashing, the system achieves:

Resilience: It remains robust against network anomalies (loss, delay, duplication) and security threats (replay, tampering, impersonation).
Scalability: The architecture supports dynamic swarm formation and can scale to large numbers of cooperating robots without requiring third-party authentication servers.
Efficiency: The low computational burden and minimal storage footprint make it viable for deployment on resource-limited edge devices like the Raspberry Pi 5, ensuring continuous and secure node-liveness monitoring in Smart Factory environments.

The authors conclude that the protocol provides a rigorous yet lightweight framework for secure industrial operations, capable of guaranteeing message authenticity and temporal correctness even under adverse network conditions.