Session 6: Architecting the Security or Security for Architectures

Mengmei Ye (Session Chair · IBM T.J. Watson Research Center), Nadja Ramhöj Holtryd (Paper author · Zero Point Technologies), Madhavan Manivannan (Paper author), Per Stenström (Paper author), Lilian Bossuet (Paper author), Carlos Andres Lara-Nino (Paper author), Théophile Gousselot (Paper author), Olivier Thomas (Paper author), Jean-Max Dutertre (Paper author), Olivier Potin (Paper author), Jean-Baptiste Rigaud (Paper author), Anthony Zgheib (Paper author)

IEEE International Symposium on Hardware Oriented Security and Trust (HOST) 2023 · Day 2 · Gateway Ballroom

Overview

This session, "Architecting the Security or Security for Architectures," at IEEE HOST 2023, delved into critical aspects of hardware security, presenting four distinct papers that highlight both the vulnerabilities and advanced countermeasures in modern computing systems. Chaired by Mengmei Ye from IBM T.J. Watson Research Center, the session underscored the increasing importance of integrating security considerations directly into architectural design, rather than treating them as an afterthought. The talks collectively addressed a spectrum of hardware-level threats, from subtle side-channel attacks exploiting shared resources to invasive code extraction techniques and sophisticated fault injection attacks targeting processor integrity.

Watch on YouTube

Visual summary for Session 6: Architecting the Security or Security for Architectures by Mengmei Ye, Nadja Ramhöj Holtryd, Madhavan Manivannan, Per Stenström, Lilian Bossuet, Carlos Andres Lara-Nino, Théophile Gousselot, Olivier Thomas, Jean-Max Dutertre, Olivier Potin, Jean-Baptiste Rigaud, Anthony Zgheib
Visual summary for Session 6: Architecting the Security or Security for Architectures by Mengmei Ye, Nadja Ramhöj Holtryd, Madhavan Manivannan, Per Stenström, Lilian Bossuet, Carlos Andres Lara-Nino, Théophile Gousselot, Olivier Thomas, Jean-Max Dutertre, Olivier Potin, Jean-Baptiste Rigaud, Anthony Zgheib

Key moments

  1. 0:00 Welcome and introduction to session on security architectures
  2. 4:00 Dynamic cache partitioning leaks secret key information
  3. 21:00 Manipulating clock frequencies for SoC covert channels
  4. 32:00 Discussion: Countermeasures and security-performance trade-offs
  5. 39:00 Demonstrating linear code extraction attack on RISC-V
  6. 46:00 Lightweight: Security marker monitoring countermeasure against extraction
  7. 59:00 CIFER: Code integrity and control flow verification solution
  8. 70:00 CIFER: Detecting fault injection attacks on control signals

Architecting the Security or Security for Architectures

Speakers: Mengmei Ye (Session Chair, IBM T.J. Watson Research Center); Nadja Ramhöj Holtryd (Zero Point Technologies); Madhavan Manivannan; Per Stenström; Lilian Bossuet; Carlos Andres Lara-Nino; Théophile Gousselot; Olivier Thomas; Jean-Max Dutertre; Olivier Potin; Jean-Baptiste Rigaud; Anthony Zgheib

Conference: IEEE HOST

YouTube: https://www.youtube.com/watch?v=kjk3-T8LhZU

Overview

This session, "Architecting the Security or Security for Architectures," at IEEE HOST 2023, delved into critical aspects of hardware security, presenting four distinct papers that highlight both the vulnerabilities and advanced countermeasures in modern computing systems. Chaired by Mengmei Ye from IBM T.J. Watson Research Center, the session underscored the increasing importance of integrating security considerations directly into architectural design, rather than treating them as an afterthought. The talks collectively addressed a spectrum of hardware-level threats, from subtle side-channel attacks exploiting shared resources to invasive code extraction techniques and sophisticated fault injection attacks targeting processor integrity.

The papers presented robust research into mitigating these threats, proposing innovative solutions that range from secure cache partitioning and covert channel detection to lightweight hardware-assisted defenses against code extraction and comprehensive control flow integrity verification. Each presentation offered a unique perspective on securing the underlying hardware foundation, emphasizing the trade-offs between security, performance, and implementation complexity. The session provided valuable insights for researchers, architects, and security practitioners grappling with the challenges of building trustworthy and resilient computing platforms in an era of increasingly sophisticated hardware-level adversaries.

Background

▶ Watch: Welcome and introduction to session on security architectures (0:00)

The landscape of modern computing is characterized by complex System-on-Chips (SoCs) and multi-core architectures, which, while offering unparalleled performance, introduce new avenues for security exploitation. Traditional software-centric security measures often fall short against attacks that leverage hardware-level phenomena. This session explored several critical facets of this challenge.

6.1 SCALE: Secure and Scalable Cache Partitioning

Modern multi-core processors extensively use shared caches to bridge the performance gap between fast cores and slow main memory. However, this shared resource can be a significant vulnerability. Cache side-channel attacks exploit the timing variability introduced by cache contention to infer sensitive information, such as cryptographic keys. While static cache partitioning offers isolation by rigidly assigning cache space to different processes, it often leads to suboptimal cache utilization and reduced performance. Conversely, dynamic cache partitioning, which adapts allocations based on application needs, improves performance but can inadvertently leak information about an application's behavior through observable changes in cache allocation. Prior work in this area struggled to balance security with performance, either failing to adapt to application requirements or reconfiguring in ways that still exposed timing differences.

6.2 Advanced Covert-Channels in Modern SoCs

Covert channels represent a fundamental challenge in secure system design. Unlike overt communication channels, covert channels allow two malicious entities (software applications or hardware IPs) to communicate illicitly by exploiting system resources not intended for communication. These channels are particularly insidious because they bypass established security policies, such as software isolation provided by TrustZone technology or logical/physical separation within an SoC. Attackers can manipulate shared physical resources like supply voltage, clock frequency, or cache memory access times to encode and transmit information. The focus of this paper was on demonstrating advanced covert channels by maliciously manipulating clock frequencies within a complex heterogeneous SoC, specifically the Xilinx Zynq UltraScale+ MPSoC.

6.3 Lightweight Countermeasures Preventing Against Linear Code Extraction Attacks on a RISC-V Core

Invasive hardware attacks pose a severe threat, particularly in contexts where intellectual property or sensitive code needs protection. Linear Code Extraction (LCE) is one such invasive attack method. Its primary goal is to extract the entire program code from a device's memory. This is especially valuable for reverse engineering, intellectual property theft, or creating counterfeit products (e.g., extracting firmware from an original ink cartridge to replicate its functionality). LCE requires highly specialized and costly tools like Focused Ion Beam (FIB) and Scanning Electron Microscopes (SEM) to perform micro-probing, where tiny electrical probes are physically connected to internal signals of the chip. The challenge lies in not just observing executed instructions but in forcing a "linear execution" where the program counter sequentially points to every instruction in memory, ensuring a complete and ordered code dump.

6.4 CIFER: Code Integrity and control Flow verification for programs Executed on a RISC-V core

Fault Injection (FI) attacks have emerged as a powerful threat to embedded systems, capable of bypassing security mechanisms by inducing transient or permanent errors in a processor's operation. A classic example is altering a conditional branch instruction during a PIN verification, allowing an attacker to gain unauthorized access despite entering an incorrect PIN. While Control Flow Integrity (CFI) solutions aim to ensure that a program's execution adheres to its intended control flow graph, many existing CFI schemes primarily focus on protecting the initial stages of the processor pipeline, such as the fetch and decode stages. However, fault injection attacks can target any micro-architectural block within a processor, including the execution units or register files. This limitation necessitates a more comprehensive approach that provides visibility and protection across the entire pipeline, referred to as Control Flow and Execution Integrity (CFEI).

Key Findings

▶ Watch: Manipulating clock frequencies for SoC covert channels (21:00)

The session brought forth several significant findings across the four presentations, each addressing distinct facets of hardware security.

6.1 SCALE: Secure and Scalable Cache Partitioning

The primary finding of the SCALE research is the successful demonstration of a secure and scalable dynamic cache partitioning solution that provides strong security guarantees without sacrificing performance. By leveraging randomization in three key areas—adding noise to allocations, randomizing the allocation change rate, and randomizing the reconfiguration period—SCALE effectively mitigates both conflict-based and occupancy-based cache side-channel attacks. Crucially, it provides quantifiable information-theoretic security guarantees based on differential privacy, allowing system administrators to configure security requirements per application using the Epsilon parameter. The solution achieved a notable 14% performance improvement over an unpartitioned shared cache, significantly outperforming prior secure partitioning methods that offered no performance benefit.

6.2 Advanced Covert-Channels in Modern SoCs

This work definitively demonstrated the feasibility and potency of clock frequency manipulation as a mechanism for establishing high-bandwidth covert channels within complex modern SoCs. Specifically, on the Xilinx Zynq UltraScale+ MPSoC, the researchers successfully established covert communication channels between different processing units (RPU to FPGA, APU to FPGA, and APU to RPU via FPGA) by dynamically altering the clock frequency of the programmable logic (FPGA) and monitoring these changes with on-chip Ring Oscillator (RO) sensors. The achieved transmission rates were substantial, reaching up to 273 Kbit/s for bare-metal applications, proving that clock-based covert channels are a serious and practical threat, not merely theoretical.

6.3 Lightweight Countermeasures Preventing Against Linear Code Extraction Attacks on a RISC-V Core

The research provided a comprehensive assessment of RISC-V core vulnerabilities to Linear Code Extraction (LCE) attacks, identifying three distinct and actionable attack paths. A key finding was that the easiest attack path, freezing a continuity instruction (e.g., forcing NOPs), requires only a single microprobe. More importantly, the paper introduced three lightweight, hardware-assisted countermeasures that effectively detect and prevent LCE attacks with minimal overhead. The most efficient, Discontinuity Instruction Monitoring, incurred less than 1% clock cycle overhead, making these solutions viable for mass deployment in embedded devices where cost and performance are critical.

6.4 CIFER: Code Integrity and control Flow verification for programs Executed on a RISC-V core

CIFER’s key finding is the successful development and implementation of a holistic Control Flow and Execution Integrity (CFEI) solution for RISC-V cores. Unlike traditional CFI methods, CIFER provides comprehensive protection against fault injection (FI) attacks by gaining visibility into and verifying the integrity of control signals across all pipeline stages (fetch, decode, execute). By generating and verifying signatures of 22 critical control signals at runtime, CIFER can detect FI attacks on any instruction of the RV32IM RISC-V ISA extension. The solution achieves this without any software performance penalty or modifications to the RISC-V compiler or user code, while incurring a manageable hardware overhead of approximately 35.2% in terms of slices on an Ibex core.

Technical Deep Dive

▶ Watch: Demonstrating linear code extraction attack on RISC-V (39:00)

This section delves into the intricate technical mechanisms and architectural considerations presented in each paper.

6.1 SCALE: Secure and Scalable Cache Partitioning

SCALE addresses cache side-channel vulnerabilities by introducing a novel dynamic cache partitioning solution founded on information-theoretic security guarantees derived from differential privacy. The core idea is to obscure an application's true cache requirements from an adversary while still allowing for performance-enhancing dynamic allocations.

The SCALE solution employs three layers of randomization:

  1. Adding Noise to Allocations: After collecting cache requirements, a non-secure dynamic allocation policy (e.g., Lookahead algorithm) determines initial allocations. Random noise, drawn from a Laplace distribution, is then added to these allocations. This noise ensures that even if an adversary observes an allocation change, they cannot deterministically infer the exact cache demand of a sensitive computation. The amount of noise is configured by the system administrator using an Epsilon (ε) parameter, which quantifies the privacy guarantee, and the "protected range," representing the maximum possible change in cache demand for a sensitive operation. For cryptographic libraries, which typically have small working set sizes, the protected range is small, leading to minimal performance costs.
  2. Randomizing the Change Rate: To counter occupancy-based attacks that exploit repeated patterns in allocation changes over time, SCALE randomizes the rate at which allocations are allowed to change. This prevents an adversary from correlating observed allocation patterns with specific secret-dependent computations.
  3. Randomizing the Reconfiguration Period: Further protection against occupancy-based attacks is achieved by randomizing the interval at which the cache partitioning policy reconfigures the cache. This makes it harder for an adversary to time their observations precisely to sensitive computational phases, as the observed cache demand might be influenced by prior, unrelated operations.

The SCALE enforcement mechanism builds upon the non-secure Delta enforcement mechanism. This mechanism uses a two-level design for cache partitioning. A hash, derived from bits following the set index, is used as an index into a cache bank table. Each unique domain ID (e.g., for a process or application) has its own cache bank table, which points to the physical cache banks where its data resides. Within these banks, data is further partitioned at the way level. This bank-and-way level partitioning provides a scalable design and allows for locality-aware data placement, contributing to performance.

Simulations using the Sniper simulator with SPEC 2006 Benchmark Suite workloads demonstrated that SCALE achieves a 14% normalized weighted speed-up over a baseline with a shared cache, significantly outperforming static partitioning and prior secure dynamic partitioning schemes. For workloads with mixed security requirements, SCALE can close the performance gap to non-secure dynamic partitioning.

6.2 Advanced Covert-Channels in Modern SoCs

This research focused on establishing covert channels on the Xilinx Zynq UltraScale+ MPSoC, a complex heterogeneous architecture comprising a Processing System (PS) with Application Processing Units (APUs) (Cortex-A53 cores) and Real-time Processing Units (RPUs) (Cortex-R5 cores), alongside a Programmable Logic (PL) (FPGA part). The architecture is divided into distinct power domains, each with its own clock frequency generated by PLLs (Phase-Locked Loops) that derive from a reference clock using configurable divider factors.

The core technical approach involves:

  1. Clock Frequency Manipulation: The malicious sender (e.g., a processing unit) changes the divider factor of the PL's PLL, thereby altering its clock frequency. This change is observable by the receiver.
  2. On-Chip Frequency Sensing: The malicious receiver, implemented in the PL (FPGA), uses Ring Oscillator (RO) based sensors to measure the clock frequency. An RO sensor consists of a chain of inverters forming a ring, whose oscillation frequency is sensitive to the local clock. This is followed by a digital counter to precisely measure the frequency. Multiple parallel sensors are used to enhance precision and reduce variability. The researchers identified optimal frequencies (e.g., 100 MHz, 150 MHz, 300 MHz) with low variability for reliable distinction.
  3. Channel Characterization: Dynamic characterization of the PLLs was performed to understand the time required for frequency transitions (e.g., ~600 nanoseconds for 150 MHz to 100 MHz transition, slightly slower for the reverse). This is crucial for determining the maximum achievable transmission rate.

Three types of covert channels were demonstrated:

  • RPU to PL (FPGA): A bare-metal application on the RPU directly writes to registers controlling the PL's PLL divider factors. Using three frequencies (100 MHz for '1', 300 MHz for '0', 150 MHz as an inter-sample frequency), a transmission rate of 273 Kbit/s was achieved.
  • APU to PL (FPGA): A Linux application on the APU uses dedicated drivers to modify the PL's frequency. This method is slower due to OS overhead. Using two frequencies (150 MHz for '1', 300 MHz for '0') and leveraging different transition times for '0' and '1' symbols, a rate of just over 1 Kbit/s was achieved. While lower, this is still sufficient for transmitting small, critical data like cryptographic keys.
  • APU to RPU via PL: This demonstrates communication between two processing units that lack direct communication paths, by relaying information through the FPGA's clock frequency. Similar modulation schemes and rates as the APU-PL channel were obtained.

The work highlights that despite different performance characteristics (bare-metal being faster than Linux applications), the ability to establish such channels poses a significant threat, capable of exfiltrating sensitive information or providing internal triggers for enhanced side-channel analysis.

6.3 Lightweight Countermeasures Preventing Against Linear Code Extraction Attacks on a RISC-V Core

The research first characterized Linear Code Extraction (LCE) attacks on a RISC-V core by identifying three main attack paths, each with varying costs for the attacker:

  1. Freezing a Continuity Instruction: This involves micro-probing the result signal of the instruction register (IR) to force it to continuously output a "no-operation" (NOP) or another simple instruction. While the program counter (PC) increments linearly through memory, the core only executes the frozen instruction. The instructions on the bus are still captured by a separate microprobe, resulting in a complete, ordered code dump. This attack is particularly efficient, requiring only one microprobe on a specific signal.
  2. Editing Incoming Instructions: This path targets the instruction bus itself. By placing microprobes on the instruction bus, an attacker can modify incoming instructions from memory, specifically converting "discontinuity instructions" (jumps, branches, calls) into "continuity instructions" (sequential operations). For a standard RISC-V ISA without extensions, this requires four microprobes to ensure that all discontinuity instructions are neutralized without creating illegal instructions. This allows the PC to advance linearly.
  3. Tampering with the Program Counter (PC): This involves directly manipulating the PC's update mechanism. By forcing the driving signal of a multiplexer that controls the PC's next value, the attacker can ensure the PC always increments sequentially. This method requires at least one microprobe, but the complexity and number of probes can increase depending on the core's extensions.

To counter these attacks, the researchers proposed three hardware-assisted countermeasures, acknowledging that software-only solutions would be overwritten or bypassed during LCE:

  1. Security Marker Monitoring (SMM): A custom instruction, the "security marker," is periodically inserted into the instruction stream by a small hardware component just after the memory on the instruction bus. A second hardware component within the core monitors the execution of these security markers. If an LCE attack occurs (e.g., an instruction is frozen or modified), the security marker will not be executed. The monitoring component detects this absence and raises an alarm. The system can then react by, for example, halting the memory or sending random instructions to the attacker. This countermeasure has a configurable latency and incurs approximately 7% clock cycle overhead when a security marker is inserted every 8 instructions.
  2. Discontinuity Instruction Monitoring (DIM): This is an optimized version of SMM. Instead of inserting custom markers, it leverages the naturally occurring discontinuity instructions (jumps, branches) already present in the code as implicit security markers. The monitoring component tracks the execution of these instructions. If an LCE attack attempts to convert them into continuity instructions, their non-execution as discontinuity instructions triggers an alarm. This approach significantly reduces overhead, measuring below 1% clock cycle overhead, as it avoids inserting additional instructions.
  3. Linear Addressing Monitoring (LAM): This passive countermeasure continuously analyzes the updates to the Program Counter (PC). If the PC is observed to update linearly (i.e., incrementing sequentially) for an unusually long period, it indicates a potential LCE attack. This solution is purely passive, involving no instruction insertion, and therefore has no clock cycle overhead.

All three countermeasures were successfully implemented and simulated, demonstrating their ability to detect the described LCE attack paths. An FPGA-based demonstration using a Nexus Video on Artix-7 was developed to emulate micro-probing, allowing real-time observation of core behavior under attack and defense scenarios without the need for expensive FIB/SEM tools. The area overhead of these countermeasures was measured to be below 1% of the considered RISC-V core. An open-source simulation framework is also available on GitHub.

6.4 CIFER: Code Integrity and control Flow verification for programs Executed on a RISC-V core

CIFER (Code Integrity and control Flow verification for programs Executed on a RISC-V core) provides a comprehensive Control Flow and Execution Integrity (CFEI) solution for RISC-V processors, designed to detect fault injection (FI) attacks across the entire pipeline. The solution is implemented on an Ibex core, a 2-stage pipeline RISC-V core (fetch and decode stages).

The technical approach is tripartite:

  1. Identification of Control Signals: The first step involves a deep analysis of the target RISC-V core's micro-architecture. Through extensive evaluation and simulations, 22 critical control signals (represented by 47 bits) were identified within the core's pipeline blocks. These signals are crucial for controlling operations like ALU function, register writes, memory access, and branch decisions. Any fault injected into these signals can alter program behavior. A mapping is established between specific instruction types (from the RV32IM ISA) and the expected values of these 47 control signals during normal execution.
  2. Generation of Metadata: For a given program, a static analysis tool parses its assembly code. It identifies all discontinuity instructions (jumps, branches, calls) and, for each basic block, generates a cryptographic signature based on the expected values of the 47 control signals. This signature is calculated using an MSR (Message-Specific Register) error model. The generated metadata is then stored in a dedicated memory accessible to the hardware verifier. This metadata specifically contains the discontinuity instructions and the signatures of the basic blocks that each discontinuity instruction can legitimately point to (e.g., for a branch instruction, signatures for both the "taken" and "not-taken" paths are stored).
  3. Runtime Verification with Hardware Module: During program execution, two hardware modules work in tandem for real-time CFEI verification:
  • MSR Module: This module is connected to the internal control signals of the RISC-V core. At runtime, it continuously monitors these 47 signals and computes a CFEI signature of the currently executing basic block.
  • Enhanced Trace Encoder: The RISC-V Trace Encoder (typically used for debugging) is enhanced for CFEI. The standard allows sending packets after sequences of discontinuity instructions. CIFER's enhancement modifies this to send a packet after each discontinuity instruction is executed. Crucially, this enhanced packet includes not only the instruction address but also the 47-bit CFEI signature computed by the MSR module for the basic block that was just executed.
  • Trace Verifier: This dedicated hardware module receives the enhanced trace packets. It extracts the address and the runtime-computed signature. It then navigates through the pre-generated metadata stored in its memory, looking for the expected signature for the basic block at that address. If the received signature does not match any of the legitimate signatures for that basic block (e.g., if a fault altered an ALU operation during a branch comparison), the Trace Verifier raises an error flag, indicating a detected FI attack.

As an example, an FI attack on a branch instruction's control signals (e.g., changing an "is not equal" comparison to an "is equal" comparison in the ALU) would result in a different control signal signature than expected. The MSR module would compute this incorrect signature, which would then be sent via the enhanced trace encoder. The Trace Verifier would detect the mismatch with the statically generated metadata, triggering an alarm.

CIFER was tested with various benchmarks from in-bench IoT's Polpino project. The metadata size ranged from 16% to 68% of the code size, depending on the number of discontinuity instructions. The hardware overhead on the Ibex core was carefully measured: the core itself uses 645 slices, with an additional 20-25 slices for MSR connections. The default trace encoder uses 239 slices, with 46 added for CIFER enhancements. The MSR module requires 58 slices, and the Trace Verifier 183 slices. In total, the Trace Verifier, MSR module, and enhanced Trace Encoder represent approximately 35.2% of the unmodified Ibex core's slice count, which is considered a manageable overhead for critical applications given the comprehensive protection offered.

Demo / Proof of Concept

▶ Watch: Lightweight: Security marker monitoring countermeasure against extraction (46:00)

Each paper presented its findings through rigorous experimental validation, ranging from detailed simulations to real-time hardware demonstrations.

6.1 SCALE: Secure and Scalable Cache Partitioning

The SCALE solution was validated through extensive simulations using the Sniper simulator. This multi-core architecture simulator was used to evaluate the performance and security guarantees of SCALE under various conditions. The researchers employed a diverse set of multi-program workloads derived from the SPEC 2006 Benchmark Suite. This allowed them to measure the "normalized weighted speed-up over baseline" as a key performance metric, comparing SCALE against a shared cache baseline and prior partitioning solutions. The simulation framework enabled detailed analysis of the impact of different Epsilon values and protected range sizes on both security and performance costs, demonstrating that for sensitive cryptographic libraries with small working sets, the performance overhead of adding noise is minimal.

6.2 Advanced Covert-Channels in Modern SoCs

The demonstration of advanced covert channels was performed on actual hardware, specifically the Xilinx Zynq UltraScale+ MPSoC. The core of the proof-of-concept involved implementing Ring Oscillator (RO) based sensors directly within the Programmable Logic (PL) (FPGA) of the SoC. These on-chip sensors were crucial for measuring the subtle changes in clock frequency induced by the transmitting malicious entity. The researchers characterized the dynamic behavior of the PLLs, measuring the precise time required for frequency transitions. The various covert channels (RPU-PL, APU-PL, APU-RPU) were practically implemented, with sender applications manipulating PLL divider factors and receiver applications monitoring the RO sensors. The output of these sensors, showing distinct frequency shifts corresponding to transmitted bits, served as the direct proof of concept for the covert communication, validating the achieved transmission rates.

6.3 Lightweight Countermeasures Preventing Against Linear Code Extraction Attacks on a RISC-V Core

The research featured a compelling FPGA-based demonstration that allowed for real-time simulation of Linear Code Extraction (LCE) attacks and the proposed countermeasures. This demonstration was built on a Nexus Video board featuring an Artix-7 FPGA. Instead of requiring costly and invasive tools like Focused Ion Beam (FIB) and Scanning Electron Microscopes (SEM) for physical micro-probing, the FPGA setup emulated micro-probing. This allowed researchers to observe the core's behavior under various LCE attack paths (e.g., freezing an instruction) and to test the effectiveness of their countermeasures (Security Marker Monitoring, Discontinuity Instruction Monitoring, Linear Addressing Monitoring) in real-time. The ability to perform these experiments without physical chip modification makes the setup highly accessible for further research and development. Additionally, an experimental setup based on a simulation framework was developed and made openly available on GitHub, enabling other researchers to reproduce and extend the vulnerability assessments and countermeasure evaluations on RISC-V cores.

6.4 CIFER: Code Integrity and control Flow verification for programs Executed on a RISC-V core

The CIFER solution was implemented and validated on an Ibex core, a 2-stage pipeline RISC-V processor. The entire CFEI framework, including the MSR module, the enhanced Trace Encoder, and the Trace Verifier, was designed and integrated with the Ibex core. The proof-of-concept involved simulating fault injection attacks at various points within the core's pipeline, specifically targeting critical control signals (e.g., an ALU operation during a branch instruction). The simulation demonstrated that when a fault was injected, the runtime-computed signature by the MSR module would differ from the statically generated metadata. The Trace Verifier would then successfully detect this mismatch and raise an alarm, confirming CIFER's ability to identify FI attacks that traditional CFI solutions might miss. Benchmarks from in-bench IoT's Polpino project and other classical benchmarks were used to evaluate the metadata size and hardware overhead, providing concrete metrics for the solution's practicality.

Defensive Implications

▶ Watch: CIFER: Detecting fault injection attacks on control signals (70:00)

The research presented in this session provides critical insights and actionable strategies for defenders aiming to enhance the security of hardware and embedded systems.

6.1 SCALE: Secure and Scalable Cache Partitioning

Defenders must recognize that shared caches are a significant attack surface for side-channel attacks. Implementing dynamic cache partitioning solutions like SCALE is crucial for sensitive applications, especially those handling cryptographic keys. Relying solely on static partitioning leads to performance degradation, while insecure dynamic partitioning introduces new side channels. Adopting solutions with information-theoretic security guarantees, such as those based on differential privacy, provides a quantifiable level of protection. System administrators should carefully configure the Epsilon (ε) parameter and the "protected range" for each application based on its sensitivity and cache behavior. This allows for a tailored security approach that balances protection with performance needs, recognizing that cryptographic libraries often have small working sets, leading to minimal overhead for strong security.

6.2 Advanced Covert-Channels in Modern SoCs

The demonstration of clock-based covert channels on modern SoCs highlights a subtle yet powerful threat. Defenders must be aware that traditional software isolation is insufficient when physical resources like clock generators can be manipulated. For highly secure systems, this implies considering stricter physical isolation of power and clock domains within an SoC, even if it comes at a performance or design complexity cost. Monitoring PLL reconfiguration requests and changes in clock frequencies from trusted hardware modules could serve as an early warning system for potential covert channel activity. Furthermore, designers should re-evaluate the accessibility of PLL control registers from less privileged software domains and implement robust access controls. The use of internal hardware-level triggers for side-channel analysis also suggests that even seemingly benign internal communication can be weaponized.

6.3 Lightweight Countermeasures Preventing Against Linear Code Extraction Attacks on a RISC-V Core

The threat of Linear Code Extraction (LCE) attacks, particularly their low cost for certain paths (e.g., one microprobe for freezing an instruction), necessitates proactive hardware-level defenses in embedded processors. For any product where the embedded code is a valuable intellectual property or contains sensitive algorithms, implementing lightweight, hardware-assisted countermeasures like Security Marker Monitoring or Discontinuity Instruction Monitoring is highly recommended. These solutions offer significant protection against invasive code extraction with minimal overhead, making them suitable for mass deployment. Designers should also consider the implications of their core's architecture on attack costs, potentially increasing the number of microprobes required for PC tampering or instruction editing through design choices.

6.4 CIFER: Code Integrity and control Flow verification for programs Executed on a RISC-V core

Defenders must move beyond traditional Control Flow Integrity (CFI) solutions that primarily protect initial pipeline stages. Fault Injection (FI) attacks can target any micro-architectural block, necessitating a comprehensive Control Flow and Execution Integrity (CFEI) approach like CIFER. For critical embedded systems, especially those in safety-critical or security-sensitive applications, integrating a CFEI solution that monitors and verifies control signals across the entire processor pipeline is essential. While this incurs hardware overhead, the ability to detect FI attacks on any instruction or control signal outweighs the cost for high-assurance systems. Designers should prioritize solutions that minimize software performance penalties and avoid modifications to compilers or user code to ensure ease of adoption and maintainability. Future work should also consider how to extend CFEI to handle indirect jumps, branch prediction, and complex interrupt scenarios.

Key Takeaways

  • Hardware-level security is paramount: Modern SoCs introduce complex attack surfaces, requiring security to be architected into the hardware from the ground up, not merely patched in software.
  • Side channels and covert channels exploit fundamental hardware characteristics: Subtle timing variations in shared caches and manipulable clock frequencies can be exploited for information leakage or illicit communication, necessitating robust isolation and monitoring mechanisms.
  • Invasive attacks are a tangible threat: Linear Code Extraction (LCE) attacks can fully compromise intellectual property, even with low-cost micro-probing, underscoring the need for integrated hardware countermeasures.
  • Comprehensive integrity is crucial against fault injection: Traditional Control Flow Integrity (CFI) is insufficient against sophisticated Fault Injection (FI) attacks; solutions like CFEI, which verify integrity across the entire processor pipeline, are essential for robust protection.
  • RISC-V is a fertile ground for security research: Its open and modular nature makes it an ideal platform for both exploring vulnerabilities and developing innovative, lightweight hardware-assisted security solutions.
  • Trade-offs are inherent in security design: Achieving strong security often involves balancing performance, hardware overhead, and implementation complexity, requiring careful consideration based on the application's specific threat model and requirements.

About the Speaker(s)

The session was chaired by Mengmei Ye, a Research Staff Member at IBM T.J. Watson Research Center, specializing in cloud infrastructure.

The first paper, "SCALE: Secure and Scalable Cache Partitioning," was presented by Nadja Ramhöj Holtryd, currently a System Architect at Zero Point Technologies in Gothenburg, Sweden. She holds a Master's degree in computer systems and networks and a PhD in computer architecture from Chalmers University of Technology, with prior industrial experience as a system developer at the Swedish Tax Agency and an embedded software developer at Volvo GTT. Her professional interests include the performance and security of memory systems. Her co-authors were Madhavan Manivannan and Per Stenström.

Lilian Bossuet presented the second paper, "Advanced Covert-Channels in Modern SoCs." He is a Professor at Jean Monnet University of Saint-Étienne in France and heads the Secured Embedded Systems and Hardware Architecture group at the university. With over 200 referred publications and a senior membership of the IEEE, his main research focus is on the hardware security of embedded systems and SoCs. His co-author was Carlos Andres Lara-Nino.

Théophile Gousselot presented the third paper, "Lightweight Countermeasures Preventing Against Linear Code Extraction Attacks on a RISC-V Core." He is a French PhD student at the EMSE research institution in the department of Secure Architecture and Systems. His research centers on the resilience of RISC-V processors against fault injections, including assessing risks of invasive attacks like laser fault injection and developing countermeasures. A software and hardware engineer, he graduated from EMSE in 2021 with a Master's degree in microelectronics and previously worked on control flow protection of RISC-V cores at STMicroelectronics. His co-authors were Olivier Thomas, Jean-Max Dutertre, Olivier Potin, and Jean-Baptiste Rigaud.

The final paper, "CIFER: Code Integrity and control Flow verification for programs Executed on a RISC-V core," was presented by Anthony Zgheib. He received an engineering Master's degree in microelectronics and computer science from EMSE school in France in 2019. He is a PhD candidate at EMSE in the Secured Architectures and Systems research department, part of a joint R&D team with CEA-Leti. His research interests lie in control flow and program execution verification for fault injection attacks and RISC-V cores. His co-authors were Olivier Potin, Jean-Baptiste Rigaud, and Jean-Max Dutertre.

Reviews

Dr. Zero (Offensive Security Researcher) — STRONG ACCEPT

This is what academic hardware security should look like: less theoretical posturing, more burned silicon. Four papers tackling everything from FPGA clock manipulation to micro-probing RISC-V cores, backed up with actual area overhead numbers. If you're taping out an SoC tomorrow, this session is mandatory viewing.

Heather Calloway (CISO) — SOLID

This is an academic deep-dive into hardware-level vulnerabilities and mitigations, specifically targeting SoCs and RISC-V architectures. While the micro-architectural details are outside a CISO's daily purview, it reinforces a critical baseline: logical isolation is only as strong as the silicon it runs on. It is a solid look at the horizon of hardware threats, though actionable primarily for OEMs and chip designers rather than enterprise security programs.

→ Top-rated talks at IEEE International Symposium on Hardware Oriented Security and Trust (HOST) 2023

All talks from IEEE International Symposium on Hardware Oriented Security and Trust (HOST) 2023