Reconciling Security Mechanisms with Real-Time Timing Constraints

14 concepts11 papers1 proposal

Real-time systems (RTS) govern safety-critical environments like autonomous drones, spacecraft, and industrial control systems. In these systems, correctness depends not just on what is computed, but when it is computed. To guarantee that critical control loops always execute on time, systems are designed around the Worst-Case Execution Time (WCET) of tasks.

As noted by Zhu et al., traditional security defenses—such as encryption, intrusion detection, and data integrity checks—consume the exact same computational and bandwidth resources as these critical control tasks. If a security mechanism introduces unexpected latency or computational overhead, it can cause a task to miss its deadline, leading to physical instability or catastrophic system failure. This creates a fundamental tension: how do you protect a system from cyber threats without destroying its real-time guarantees?

The Vulnerability of Predictable Schedules

The irony of real-time systems is that their greatest asset—strict temporal predictability—is also a severe security vulnerability. Because tasks must execute deterministically to guarantee safety, an attacker can exploit this regularity.

For instance, Chen et al. demonstrated a side-channel attack called ScheduLeak, where a low-priority malicious task observes its own execution interruptions to infer the exact arrival times of high-priority victim tasks with over 97% accuracy. This predictability allows attackers to launch highly targeted exploits, such as overriding drone control signals at precise moments.

Defending against these timing attacks is notoriously difficult. Standard defensive techniques like schedule randomization or dynamic voltage and frequency switching (DVFS) can obscure side-channel signatures (Yang et al.). However, as Chen et al. point out, introducing temporal randomization or jitter directly threatens the system's determinism, potentially causing safety-critical tasks to miss deadlines.

Exploiting System Slack for Opportunistic Security

To resolve this conflict, researchers have developed frameworks that treat security as an opportunistic or adaptive property rather than a fixed overhead. Real-time tasks are allocated based on their WCET, but in practice, they rarely execute for their maximum duration. This difference between the worst-case and actual execution time creates "slack."

Rather than allowing security tasks to interfere with the critical path, frameworks like Contego, proposed by Hasan et al., introduce adaptive security tasks that switch between active and passive modes depending on available system resources. Building on this concept, Hasan et al. developed HYDRA, a design-space exploration algorithm for multicore systems that treats security monitoring as low-priority, opportunistic tasks, strategically distributing them across cores to maximize threat detection without disrupting critical control logic.

Similarly, Wang et al. introduced Opportunistic Data Flow Integrity (OP-DFI). OP-DFI reserves a portion of the system's execution time for data-flow validation but dynamically yields this time if critical control tasks require it. By leveraging inherent system slack, it enforces strong memory safety guarantees without violating real-time boundaries.

Traditional Fixed Security Overhead:
[ Task A (Control) ][ Security Check ][ Task B (Control) ] -> High Risk of Deadline Miss

Opportunistic Security (Slack Reclamation):
[ Task A (Actual Execution) ][ Slack Time -> Run Security Check ] [ Task B (Control) ]

Optimizing the Worst-Case Execution Path

When security checks cannot be deferred and must be executed inline, the goal shifts from reclaiming slack to minimizing the security mechanism's impact on the WCET itself.

Consider Data-Flow Integrity (DFI), which prevents memory corruption attacks by verifying the origin of every piece of loaded data. Enforcing DFI globally introduces massive performance overhead. To make DFI viable for real-time systems, Feng et al. developed RT-DFI. Instead of optimizing all code equally, the authors use an Integer Linear Programming (ILP) solver to specifically optimize and prune DFI checks along the Worst-Case Execution Path (WCEP). Because the system's overall schedulability is determined solely by its worst-case path, reducing overhead along the WCEP directly improves the system's timing guarantees, achieving a significant reduction in WCET.

Lightweight Architectural Isolation

Beyond scheduling and software optimization, hardware-assisted isolation must also be adapted for real-time constraints. Traditional Trusted Execution Environments (TEEs), like standard implementations of ARM TrustZone, introduce unpredictable context-switching latencies that are unacceptable for low-end Real-Time Operating Systems (RTOSs).

To bridge this gap, Liu et al. designed MiniTEE, a lightweight TEE tailored for real-time embedded systems. By streamlining the context-switching mechanics and minimizing the TEE's footprint, MiniTEE provides robust hardware-enforced isolation for sensitive operations (like cryptographic key management) while maintaining the predictable timing required by autonomous vehicles and drones. This architectural refinement ensures that isolation does not come at the cost of temporal determinism, a principle that also mirrors software-level isolation frameworks designed for distributed platforms like spacecraft (Otte et al.).

Towards Resource-Aware Security Co-Design

Ultimately, this body of research demonstrates that security cannot be treated as an afterthought or an isolated layer in real-time systems. As systems become more interconnected—stretching from decentralized edge networks (Anisetti et al.) to distributed aerospace platforms—security and real-time scheduling must be co-designed. By treating security as a resource-aware, schedulable constraint, these frameworks ensure that protecting a system from digital adversaries does not cause it to fail in the physical world.

Key Foundational Work

Power Attack Resistant Cryptosystem Design: A Dynamic Voltage and Frequency Switching Approach (2005) — contributed 1 concept elements to this direction.
A resilient and secure software platform and architecture for distributed spacecraft (2014) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_security_performance_trade_offs_176bd5ee,
  title = {security-performance trade-offs},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/security-performance-trade-offs/rdr_176bd5ee09304101ab4e3aa74cafd40f},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_security_performance_trade_offs_176bd5ee_v1,
  title = {security-performance trade-offs},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/security-performance-trade-offs/rdr_176bd5ee09304101ab4e3aa74cafd40f/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake