💻 computer science

ENOLA: Linear-Space and Low-Overhead Control-Flow Attestation for Microcontroller-based Systems

This paper introduces ENOLA, a linear-space and low-overhead control-flow attestation solution for microcontroller-based systems that leverages hardware-assisted measurements and register-based storage to overcome scalability, security, and performance limitations of existing approaches.

Original authors: Md Armanuzzaman, Engin Kirda, Ziming Zhao

Published 2026-08-12

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Md Armanuzzaman, Engin Kirda, Ziming Zhao

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 you are the security guard for a tiny, battery-powered robot that lives in a remote forest. This robot has a very important job: it must follow a specific set of instructions to water the plants. If a hacker sneaks in and tricks the robot into taking a wrong turn, the plants might die, or worse, the robot could be hijacked to do something dangerous. To make sure the robot is doing its job correctly, a human back at the base station needs to ask the robot, "Show me exactly where you went." This process is called Control-Flow Attestation. It's like asking the robot to hand over a detailed logbook of every single step it took.

However, there's a catch. The robot is tiny and has very little memory and battery power. If the robot tries to write down every single step in a giant, messy notebook, it will run out of ink (memory) and battery long before it finishes its job. Furthermore, if the hacker can sneak into the robot's memory and erase or change the logbook, the human back at the base won't know the robot was tricked. Existing solutions for bigger, more powerful computers are like trying to carry a library of encyclopedias in a backpack; they are too heavy and slow for these tiny robots. The big question is: How can we get a tiny, weak robot to prove it walked the right path without exhausting its resources or letting a hacker fake the proof?

Enter ENOLA, a clever new solution designed specifically for these tiny microcontroller-based systems. Think of ENOLA as a smart, magical compass and a super-efficient scribe working together. Instead of making the robot write down every single step in a long, boring list, ENOLA uses a special trick: it only records where the robot stopped to look around (the "basic blocks") and how many times it visited each spot. This turns a massive, sprawling logbook into a tiny, neat checklist that fits in the robot's pocket.

But ENOLA doesn't just shrink the list; it also makes the list unforgeable. It uses a special hardware feature built into modern microchips (called Pointer Authentication) to stamp the checklist with a digital seal that is mathematically impossible to fake without the secret key. Crucially, instead of writing this seal on a piece of paper that a hacker could tear up or scribble on (memory), ENOLA keeps the seal locked inside a special, protected pocket inside the robot's brain (a hardware register). This means even if a hacker tries to mess with the robot's memory, they can't touch the proof.

The researchers tested ENOLA on real-world applications, including a program that controls a syringe pump and a large security library called wolfSSL. The results were impressive: compared to previous methods, ENOLA reduced the amount of data the robot had to send back to the base station by an average of 52 times. For example, while an older method might have sent back 21,009 bytes of data for a standard test program, ENOLA only needed 397 bytes. Even more importantly, ENOLA managed to handle huge, complex programs like wolfSSL, which had 5,480 basic blocks, something previous methods couldn't do without crashing or taking forever.

The paper shows that ENOLA is not just a theoretical idea but a working prototype. It successfully proved that you can verify a program's path on a tiny, resource-constrained device without slowing it down too much or making it vulnerable to memory attacks. While it does add a small amount of work for the robot to do (an overhead that varies by program, sometimes around 1.3% and other times higher depending on the task), the trade-off is worth it because it finally makes secure verification possible for the billions of tiny devices we rely on every day. The authors suggest that while this is a major step forward, there is still room to make it even faster in the future, perhaps by using different hardware features or simplifying the process even further.

Technical Summary: ENOLA – Linear-Space and Low-Overhead Control-Flow Attestation for Microcontroller-based Systems

Problem Statement

Control-Flow Attestation (CFA) aims to verify the execution path of a program to a remote verifier. However, existing solutions (e.g., C-FLAT, LO-FAT, OAT, Blast) are fundamentally incompatible with resource-constrained microcontroller (MCU) systems due to three primary limitations:

Scalability of Data Transmission: The size of transmitted measurement and trace data in existing schemes scales poorly. It often grows exponentially with the number of basic blocks (due to path enumeration in loops) or linearly with the length of execution traces. This renders them impractical for larger programs, even on high-end microprocessors, and entirely infeasible for MCUs.
Memory Vulnerability: Cryptographic keys and measurement data are typically stored in memory without encryption or integrity protection. This exposes them to cold boot and memory corruption attacks, a critical threat for field-deployed devices. Even Trusted Execution Environments (TEEs) like ARM TrustZone isolate memory but do not inherently encrypt it.
Performance Overhead: Reliance on software-based hash functions and frequent context switches between the Rich Execution Environment (REE) and the TEE for both forward (call/jump) and backward (return) control-flow events introduce significant latency on resource-constrained MCUs.

Methodology: The ENOLA Approach

ENOLA is a CFA solution designed specifically for MCU-based systems (targeting ARMv8.1-M architecture) that addresses the above challenges through a combination of algorithmic design, hardware utilization, and compiler instrumentation.

1. Linear-Space Authenticator Design

ENOLA introduces a novel authenticator structure, $Auth = (T, M)$, where $T$ is a basic block occurrence trace and $M$ is a pair of cumulative measurements ( $M_f$ for forward paths, $M_b$ for backward paths).

Trace ( $T$ ): Instead of recording full execution traces or path enumerations, ENOLA records the occurrence count of each basic block start address ( $v_i.s$ ) and a list of invalid indirect branch targets. This ensures the trace size scales linearly with the number of basic blocks ( $O(|V|)$ ), regardless of loop iterations or execution length.
Measurements ( $M$ ): Forward and backward paths are hashed using a keyed Message Authentication Code (MAC) chain.
- Forward ( $M_f$ ): Computed at the entry of destination basic blocks for forward branches.
- Backward ( $M_b$ ): Computed at function returns. Crucially, ENOLA does not report the backward path trace to the TEE, eliminating context switches for return events.

2. Hardware-Assisted Security and Efficiency

Pointer Authentication (PA): ENOLA leverages the ARMv8.1-M Pointer Authentication (PA) extension (specifically the pacg instruction) for measurement computation. This provides hardware-accelerated MAC generation, offering significantly higher speed than software-based hash functions (e.g., BLAKE2).
Register Reservation: To prevent memory corruption attacks, ENOLA reserves two general-purpose registers ( $r10$ and $r11$ ) exclusively for storing the cumulative measurement chains ( $M_f$ and $M_b$ ). These registers are never spilled to memory. The measurement keys are loaded into PA key registers within the TEE and are never exposed to the REE memory.
Secure ISR Dispatcher: To handle Interrupt Service Routines (ISRs) which are outside the Trusted Computing Base (TCB), ENOLA employs a secure dispatcher. It intercepts interrupts, saves the program context and measurement state to secure memory, marks the program stack as read-only during ISR execution, and restores the state upon return. Deviations in ISR behavior are flagged in the trace.

3. Compiler and System Workflow

Compile-Time: The ENOLA compiler (LLVM-based) instruments the source code to:
- Insert calls to secure reporting interfaces (report_direct, report_indirect) for basic block occurrences.
- Insert pacg instructions to update measurements at branch targets and function returns.
- Generate an Indirect Target List (ITL) for the verifier to validate indirect branch destinations.
- Scan the binary to ensure no unauthorized instructions (e.g., msr to PA keys, ROP gadgets) can tamper with reserved registers.
Run-Time: The attested program runs in the normal state (REE), while the attestation engine runs in the secure state (TEE). The engine configures PA keys, enforces Memory Protection Unit (MPU) policies (W⊕X), and collects the trace and measurements.
Verification: The remote verifier reconstructs the control flow graph, performs abstract execution guided by the trace, and verifies the measurements against the received authenticator.

Key Contributions

Formal Analysis of CFA Complexity: The paper formalizes the space complexity of existing CFA schemes, identifying that their reliance on trace or measurement data creates a fundamental scalability bottleneck for MCUs.
ENOLA Authenticator: A novel authenticator design achieving linear space complexity ( $O(|V|)$ ) relative to the number of basic blocks, enabling scalable attestation for large programs.
Hardware-Integrated Security: The first implementation to utilize ARM PA for control-flow attestation on embedded systems, keeping measurement keys and chains in registers/PA hardware to thwart memory corruption.
Context Switch Reduction: Elimination of TEE context switches for backward-edge (return) measurements by computing them directly in the REE using PA instructions.
Implementation and Evaluation: A full implementation on the Cortex-M85 (ARMv8.1-M) using LLVM passes, validated on real-world applications including the Embench suite and wolfSSL.

Results

The evaluation was conducted on a Cortex-M85 MCU running at 25 MHz, comparing ENOLA against Blast (the most efficient prior work) and other schemes.

Data Transmission Overhead: ENOLA drastically reduces the size of the attestation report. On the Embench suite, ENOLA reduced transmitted data by an average of 52x compared to Blast. For example, Blast produced an average of 21,009 bytes of attestation data, whereas ENOLA required only 397 bytes.
Scalability: ENOLA successfully scaled to large, real-world applications like wolfSSL (specifically the RSA module with 5,480 basic blocks), a task where prior solutions failed or were limited to small snippets.
Performance Overhead:
- Execution Time: ENOLA's overhead varies by application and optimization level. For the syringe pump application, it achieved a low overhead of 1.3% for the move-syringe path. Across Embench benchmarks, overheads ranged significantly (e.g., 9.81% to over 1000% in specific cases), but were generally competitive with or lower than Blast when considering the granularity of attestation (basic-block level vs. function-level).
- Context Switches: Context switching accounted for approximately 26% of the total runtime overhead under O2 optimization.
Code Size: Code size overhead averaged around 30-40% with O2 optimization, significantly lower than Blast's 64% overhead on Embench.

Significance and Claims

The paper claims that ENOLA represents a significant step forward in making Control-Flow Attestation feasible for microcontroller-based systems. By decoupling the attestation size from the execution trace length and leveraging hardware primitives (PA, TrustZone, MPU) to secure measurement states without memory storage, ENOLA enables the verification of large, complex embedded applications for the first time. The authors position ENOLA not just as a performance improvement, but as a necessary evolution to address the fundamental scalability and security limitations of existing CFA approaches in the embedded domain. The work is open-sourced to facilitate further research and adoption.