⚡ electrical engineering

RobResilience: Implementing and Evaluating a Resilience Framework for Cyber-Physical Embodied Systems

This paper presents RobResilience, a runtime framework implemented in a Webots simulation with a PR2 robot and ROS2 that evaluates tolerable disruption, degradation, and mitigation feasibility to prevent graceful failure paralysis in embodied cyber-physical systems under active cyberattacks, with experimental results confirming its consistency with theoretical definitions.

Original authors: Gysella Imrell, Emanuele Miotto, Mahya Mohammadi Kashani, Mauro Conti, Alberto Giaretta

Published 2026-09-16

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Gysella Imrell, Emanuele Miotto, Mahya Mohammadi Kashani, Mauro Conti, Alberto Giaretta

Original paper licensed under CC BY 4.0 (http://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 robots are no longer just tools in a factory, but active participants in our daily lives, moving through our homes, hospitals, and streets. These machines, known as cyber-physical systems, blend digital brains with physical bodies. They sense their surroundings, make decisions, and act on them. But this tight connection creates a dangerous vulnerability. When a hacker attacks a standard computer, the worst that usually happens is lost data or a frozen screen. When a hacker attacks a robot that is holding a heavy object or driving near a person, the consequences can be physical injury or even death. The challenge for scientists is not just to spot an attack when it happens, but to help the robot survive it. A robot needs to know the difference between a minor glitch it can ignore and a catastrophic failure that requires it to stop immediately to stay safe.

For years, security experts have focused on detecting intrusions, acting like a burglar alarm that rings when a window is broken. However, an alarm alone does not tell a robot whether it can still finish its job or if it is in immediate danger. This gap leaves autonomous systems vulnerable to a kind of paralysis where they cannot distinguish between a safe, degraded state and a catastrophic hazard. To solve this, researchers at Örebro University in Sweden have built and tested a new framework called RobResilience. They created a digital twin of a real robot, a large service machine called the PR2, inside a sophisticated simulation environment. This virtual robot was tasked with navigating a room and picking up a water bottle, a simple job that requires precise coordination between its wheels, arms, and sensors. The researchers then subjected this virtual robot to a series of simulated cyberattacks, ranging from slowing down its wheels to freezing its grippers, to see if their new framework could guide the robot through the chaos.

The core of their work is a set of three logical questions the robot asks itself in real-time whenever it senses something is wrong. The first question is about disruption: is the part that is broken essential for the task at hand? If the robot is trying to move and its wheels are hacked, the answer is yes, and the task is disrupted. If the robot is trying to pick up a bottle and only its non-essential camera is hacked, the answer is no, and the task can continue. The second question is about degradation: even if the robot can still move, is it performing so poorly that it is no longer safe or useful? Perhaps the robot is moving so slowly that it will miss a deadline, or its arm is shaking so much it might drop the bottle. The third question is about mitigation: if the robot is in trouble, is there a way to fix it? Can it switch to a backup wheel, or reconfigure its software to work around the broken part?

The researchers tested these questions across eight different attack scenarios, systematically changing which parts of the robot were attacked, how badly they were damaged, and whether a fix was available. In one scenario, they attacked the robot's arms, which were not critical for the simple task of moving to a destination. The robot's system correctly identified that the disruption was tolerable and allowed the task to continue, even though the robot was moving slightly slower. In another scenario, they attacked the wheels, which were critical. Without a fix available, the system correctly determined that the robot could not continue safely and ordered it to stop immediately. The most complex tests involved situations where the robot was both disrupted and degraded, but a fix was possible. In these cases, the framework successfully identified the available solution, neutralized the attack on the specific component, and allowed the robot to resume its task, albeit with a slight delay.

The results of these simulations were consistent with the theoretical rules the researchers had designed. The system proved capable of making the right call in every situation it was tested on. When the robot was safe to continue, it kept going. When it was in danger, it stopped. When it could be saved, it was saved. The study also revealed a subtle but important detail: the robot's resilience depends not just on which single part is broken, but on the combination of broken parts. A robot might survive the loss of one non-essential part, but if that loss is added to an existing problem, the combined effect could push the robot past the point of safety. This means that a robot's ability to survive an attack is not a fixed trait of its hardware, but a dynamic state that changes with every new piece of information it receives.

It is important to note that these findings come from a controlled digital environment. The researchers used a simulation to model the attacks and the robot's reactions, rather than testing on a physical robot in the real world. This allowed them to run hundreds of variations quickly and safely, but it also means the results have not yet been proven on actual hardware that might face real-world noise, timing delays, or unpredictable physical forces. The researchers acknowledge this limitation and view their work as a crucial first step. They have demonstrated that the logic for resilience works as intended in a simulation, providing a blueprint for how future robots might be programmed to think about their own safety during an attack.

The ultimate goal of this research is to move beyond simple detection and toward a future where robots can adapt to threats on the fly. By giving machines the ability to reason about their own operational limits, the researchers hope to prevent the kind of total system failures that could endanger human safety. The framework does not prevent the attack from happening, but it ensures that when an attack does occur, the robot does not panic or freeze. Instead, it assesses the damage, weighs its options, and makes a calculated decision to either continue, recover, or stop. This shift from passive defense to active resilience represents a significant step forward in making autonomous systems safe enough to share our world.

Technical Summary: RobResilience

Problem Statement

In embodied Cyber-Physical Systems (CPS), such as autonomous robots, active cyberattacks pose immediate threats not only to data integrity but to physical safety and operational continuity. While existing security research excels at intrusion detection, it often lacks runtime mechanisms to determine whether a detected disruption is tolerable or if performance degradation remains within safe operational bounds. This gap leaves autonomous systems vulnerable to "graceful failure paralysis," where they cannot distinguish between a safe, degraded state and a catastrophic hazard during an ongoing attack. Current intrusion response systems often address runtime response but fail to reason formally about disruption or degradation tolerability under active attacks.

Methodology

The paper presents RobResilience, an implementation and evaluation of a formal resilience framework for embodied CPSs. The work follows a Design Science Research approach, situating the framework within a simulation environment to model how cyberattack scenarios influence system behavior.

Theoretical Framework

The system models a robot $R$ as a set of devices $D$ performing tasks $T$ and preserving goals $G$ . The framework relies on three core runtime predicates evaluated over a set of compromised devices $S$ (derived from Intrusion Detection System confidence scores):

Tolerable Disruption ( $\delta$ ): Evaluates whether the set of compromised devices includes any device strictly required (criticality level 2) for active tasks or goals.
Tolerable Degradation ( $\gamma$ ): Evaluates whether system performance $\psi(S)$ remains within acceptable bounds ( $\theta$ ). This bound is stricter ( $\theta_{crit}$ ) if critical devices are compromised and relaxed ( $\theta_{base}$ ) otherwise.
Mitigation Feasibility ( $\mu$ ): Evaluates whether a subset of compromised devices can be neutralized to restore both $\delta$ and $\gamma$ to acceptable states.

A system is defined as resilient if $(\delta(S)=1 \land \gamma(S)=1) \lor \mu(S)=1$ .

Implementation Architecture

The framework was implemented in a Webots simulation environment using a PR2 robot and ROS2. The architecture consists of four modules:

Simulation Environment: Hosts the PR2 robot and physics dynamics.
Coordination Controller: Orchestrates task execution, manages inter-module communication, and integrates mitigation commands.
Attack Injection Module: Simulates external attackers by publishing symbolic message-based attacks (e.g., STOP, UNDERSPEED, OVERSPEED) to specific devices via ROS2 topics.
Resilience Evaluation Module: Contains the IDS (which maps attack confidence to a compromised set $S$ ) and the Resilience Manager (which evaluates $\delta$ , $\gamma$ , and $\mu$ and triggers mitigation).

The degradation function $\psi$ was instantiated as a weighted exponential function, penalizing the loss of critical devices more steeply than non-critical ones.

Key Contributions

Executable Implementation: The paper provides the first executable implementation of the formal resilience framework defined in prior theoretical work [7]. It realizes criticality mappings, IDS integration, and runtime predicate evaluation as deployable software modules within a ROS2/Webots environment.
Predicate Consistency Verification: The implementation demonstrates conformance to expected behaviors across all realizable combinations of the $\delta$ , $\gamma$ , and $\mu$ predicates. It confirms that the system correctly distinguishes between critical and non-critical attack targets and handles the interplay between disruption and degradation.
Empirical Analysis of Resilience Dynamics: The study provides an empirical analysis of how degradation severity, task-criticality mappings, and adaptive mitigation jointly determine operational continuity. It highlights that resilience is sensitive to the cumulative composition of the compromised set, not just the criticality of individual devices.

Evaluation and Results

The evaluation utilized eight attack scenarios designed to systematically cover all possible combinations of the predicate state space. The scenarios varied attack targets (critical vs. non-critical), degradation rates, and mitigation availability.

Non-Disrupted Scenarios ( $\delta=1$ ): When attacks were confined to non-critical devices, the system maintained $\delta=1$ . However, high degradation rates could still drive $\gamma$ to 0, causing task halts unless mitigation was available (Scenarios 1, 2a, 2b).
Disrupted Scenarios ( $\delta=0$ ): Attacks on critical devices immediately set $\delta=0$ $δ = 0$ .
- In scenarios where degradation remained within bounds ( $\gamma=1$ ) but no mitigation was available, the system halted (Scenario 3a).
- In scenarios where mitigation was available, the system successfully restored $\delta$ to 1, allowing task completion (Scenario 3b).
- In the most severe case ( $\delta=0, \gamma=0$ ), the system halted without mitigation (Scenario 4a) but successfully recovered to a resilient state when mitigation neutralized the critical device (Scenario 4b).

The results confirm that the runtime behavior of the implementation is consistent with the theoretical definitions. Specifically, the framework correctly identifies that a system can be disrupted ( $\delta=0$ ) yet still operate within tolerable performance bounds ( $\gamma=1$ ), and that mitigation can restore resilience even when both predicates are initially violated.

Significance and Limitations

The paper claims significance in bridging the gap between detection and adaptive runtime response. By formalizing resilience as a set of runtime predicates, RobResilience enables autonomous systems to make informed decisions about whether to continue, degrade gracefully, or halt during an attack, rather than relying solely on detection alerts.

The authors explicitly note the following limitations and scope:

Simulation-Only: The evaluation is limited to the Webots simulation environment and does not extend to physical hardware deployment.
Idealized Detection: To isolate the resilience logic, the IDS thresholds ( $\kappa$ ) were set to 0, effectively assuming 100% detection accuracy. This bypasses the probabilistic nature of real-world IDS.
Symbolic Attacks: Attacks were injected as symbolic messages rather than real-world exploits or network-level intrusions.
Deterministic Mitigation: Mitigation actions were modeled as deterministic and fully resolving, whereas real-world mitigations may be partial or stochastic.

The paper concludes that while the framework successfully validates the theoretical predicate semantics, future work is required to integrate realistic probabilistic IDS models, real-world attack vectors, and physical deployment to address timing and noise constraints inherent in embodied systems.