Session 4: Whose Fault is it?
Sohrab Aftabjahani (Session Chair · Intel), Sadullah Canakci (Paper author · Boston University), Chathura Rajapaksha (Paper author), Anoop Mysore Nataraja (Paper author), Leila Delshadtehrani (Paper author), Michael Taylor (Paper author), Manuel Egele (Paper author), Ajay Joshi (Paper author), Susanne Engels (Paper author), Maik Ender (Paper author), Christof Paar (Paper author), Pascal Nasahl (Paper author), Salmin Sultana (Paper author), Hans Liljestrand (Paper author), Karanvir Grewal (Paper author), Michael LeMay (Paper author), David M. Durham (Paper author), David Schrammel (Paper author), Stefan Mangard (Paper author)
IEEE International Symposium on Hardware Oriented Security and Trust (HOST) 2023 · Day 2 · Gateway Ballroom
Overview
This article dissects a comprehensive technical session from IEEE HOST, focusing on cutting-edge research in hardware security, verification, and fault attack countermeasures. The session, titled "Whose Fault is it?", presented three distinct papers that collectively highlight the evolving landscape of hardware vulnerabilities and defensive strategies. From advanced processor fuzzing techniques to targeted fault injection on FPGAs and cryptographic control-flow integrity, the talks underscore the increasing complexity of securing modern hardware against both accidental bugs and malicious adversaries.

Key moments
- 0:00 Introduction to ProcessorFuzz and hardware fuzzing
- 7:00 ProcessorFuzz: CSR transition coverage for bug discovery
- 16:31 Targeted Bitstream Fault Fuzzing: Accelerating FPGA attacks
- 19:30 Brute-force FPGA fault fuzzing: The 182-month problem
- 26:00 TBFF results: 1600x speedup in FPGA fault injection
- 34:28 EC-CFI: Control-Flow Integrity via Code Encryption
- 42:30 EC-CFI: Fine-grained memory encryption on Intel CPUs
- 48:00 EC-CFI Q&A: Protecting against fault attacks vs. CET
Whose Fault is it?
Speakers: Sohrab Aftabjahani (Session Chair, Intel); Sadullah Canakci (Paper author, Boston University); Chathura Rajapaksha (Paper author); Anoop Mysore Nataraja (Paper author); Leila Delshadtehrani (Paper author); Michael Taylor (Paper author); Manuel Egele (Paper author); Ajay Joshi (Paper author); Susanne Engels (Paper author); Maik Ender (Paper author); Christof Paar (Paper author); Pascal Nasahl (Paper author); Salmin Sultana (Paper author); Hans Liljestrand (Paper author); Karanvir Grewal (Paper author); Michael LeMay (Paper author); David M. Durham (Paper author); David Schrammel (Paper author); Stefan Mangard (Paper author)
Conference: IEEE HOST
YouTube: https://www.youtube.com/watch?v=GyYapU0IYrM
Overview
This article dissects a comprehensive technical session from IEEE HOST, focusing on cutting-edge research in hardware security, verification, and fault attack countermeasures. The session, titled "Whose Fault is it?", presented three distinct papers that collectively highlight the evolving landscape of hardware vulnerabilities and defensive strategies. From advanced processor fuzzing techniques to targeted fault injection on FPGAs and cryptographic control-flow integrity, the talks underscore the increasing complexity of securing modern hardware against both accidental bugs and malicious adversaries.
The first paper, "ProcessorFuzz: Processor Fuzzing with Control and Status Registers Guidance," introduces a novel hardware fuzzer designed to efficiently uncover functional bugs in complex processors by leveraging Control and Status Register (CSR) transitions. This work addresses the scalability and accuracy limitations of prior hardware fuzzing methodologies. The second presentation, "Targeted Bitstream Fault Fuzzing - Accelerating BiFI on Large Designs," tackles the challenge of practical bitstream fault injection (BiFI) attacks on modern, large-scale FPGAs. It proposes an automated reverse-engineering approach to pinpoint critical components, drastically reducing the time required for successful fault injection.
Finally, "EC-CFI: Control-Flow Integrity via Code Encryption Counteracting Fault Attacks" explores a cryptographic approach to Control-Flow Integrity (CFI), specifically designed to defend against fault attacks. This paper demonstrates how existing Intel hardware features, particularly the Total Memory Encryption - Multi-Key (TME-MKT) engine, can be repurposed to achieve fine-grained memory encryption and robust CFI without requiring new hardware modifications, albeit with a discussion on performance implications and potential future hardware enhancements. Together, these papers provide critical insights into both offensive and defensive aspects of hardware security, vital for researchers, designers, and security practitioners.
Background
▶ Watch: Introduction to ProcessorFuzz and hardware fuzzing (0:00)
The increasing complexity of modern processors and FPGAs has made comprehensive hardware verification an enormous challenge. With millions of gates and intricate interdependencies, traditional verification methods, such as formal methods, often face the state explosion problem, limiting their scalability. Dynamic verification methods, while more scalable, typically offer incomplete coverage due to the vast input space. This inherent difficulty has led to a persistent presence of hardware bugs, which, as past incidents have shown, can have severe security implications, ranging from unauthorized access to sensitive data leaks through side channels, even bypassing robust security features like Intel SGX and AMD SEV.
Inspired by the success of fuzzing in software, where it has uncovered thousands of critical bugs, the hardware security community has increasingly adapted fuzzing techniques for hardware verification. However, direct adaptation is difficult due to fundamental differences in input types, execution models, feedback mechanisms, and bug identification between software and hardware. Early hardware fuzzers, like ArFuzz, relied on multiplexer selection single toggle coverage, which proved unscalable for complex designs. DiffuzeRTL attempted to improve this by focusing on registers that indirectly or directly influence multiplexer selection signals, but it often monitored numerous data path registers, leading to misleading coverage and inefficient bug discovery.
On the FPGA front, these devices offer immense flexibility through reprogrammable logic and routing configured by a bitstream. While this flexibility is powerful, it also introduces unique attack surfaces. Fault attacks, traditionally involving physical manipulation like laser injection, can corrupt internal states of cryptographic ciphers, leading to key leakage. A more stealthy approach involves manipulating the FPGA bitstream directly, introducing "static faults" by altering the Boolean function of Lookup Tables (LUTs). The challenge here is the sheer number of LUTs in modern FPGAs—over 1.2 million in Xilinx 7 Series devices—making brute-force bitstream manipulation impractical, potentially requiring months or even years.
For general processor security, Control-Flow Integrity (CFI) is a crucial defense mechanism against various software exploitation techniques that aim to hijack program execution. However, traditional CFI schemes primarily focus on software-based adversaries. The emergence of fault attacks, which can manipulate instruction pointers, return addresses, or CPU pipelines directly, poses a significant challenge to existing CFI implementations. These attacks, once requiring physical access, can now be launched remotely through methods like VoltJockey, Plundervolt, and ClockScrew, expanding the threat model to cloud environments. Counteracting such attacks necessitates novel CFI approaches that can detect and mitigate control flow deviations induced by physical faults. Intel's TME-MKT (Total Memory Encryption - Multi-Key) engine, designed for memory encryption at a page granularity, presents an opportunity to build such a defense, but its page-level granularity needs to be overcome for fine-grained protection.
Key Findings
▶ Watch: Targeted Bitstream Fault Fuzzing: Accelerating FPGA attacks (16:31)
The session's papers collectively advanced the state of hardware security through innovative fuzzing, targeted fault injection, and cryptographic defense mechanisms.
"ProcessorFuzz" introduced a scalable and effective hardware fuzzer for processors. Its key finding is that CSR transition coverage provides a more insightful and less misleading feedback mechanism for hardware fuzzing compared to prior register-based or multiplexer-based approaches. By leveraging ISA simulation for rapid input filtering, ProcessorFuzz achieved significant speedups—1.21x and 1.23x over NorCal and DiffuzeRTL respectively on known bugs in Rocket and Boom cores. Crucially, it demonstrated its practical efficacy by discovering eight new functional bugs in real-world open-source processors, including Rocket Core, Boom Core, and Blackbird, with an average speedup of 1.6x against random generators for Blackbird.
"Targeted Bitstream Fault Fuzzing" presented a breakthrough in making Bitstream Fault Injection (BiFI) practical on large FPGA designs. The core finding is the development of an automated reverse-engineering methodology to precisely identify vulnerable Lookup Tables (LUTs) within an FPGA bitstream. By using tools like Project X-Ray, HAL, and the Dana algorithm, the researchers could reduce the attack surface from millions of LUTs to just a handful (e.g., 1-3 target LUTs for AES designs). This targeted approach drastically accelerated attack times, achieving speedups of up to 1600x (reducing attack time from 60-180 hours to 6-20 minutes) and even over 6000x in combined designs, making BiFI a viable threat for complex systems.
"EC-CFI" demonstrated a novel approach to Control-Flow Integrity (CFI) that effectively counteracts fault attacks by leveraging code encryption. The central finding is the ability to achieve fine-grained memory encryption on Intel CPUs using the existing TME-MKT engine and virtualization features, specifically by dynamically switching between multiple Extended Page Tables (EPTs) with the VMFUNC instruction. This cryptographic CFI scheme ensures that any fault-induced control flow deviation results in a decryption key mismatch, leading to the fetching of "gobbled instructions" and an immediate illegal instruction exception, thereby offering minimal detection latency. While the initial overhead was high (factor 6), the paper also proposed a minimal hardware modification (a dedicated Key ID register) that could reduce the overhead to a reasonable 1.21x, highlighting a path towards practical deployment.
Technical Deep Dive
▶ Watch: TBFF results: 1600x speedup in FPGA fault injection (26:00)
ProcessorFuzz: Processor Fuzzing with Control and Status Registers Guidance
ProcessorFuzz addresses the inherent limitations of traditional hardware verification and prior hardware fuzzing techniques. The core innovation lies in its feedback mechanism, which is guided by Control and Status Register (CSR) transition coverage. Unlike ArFuzz, which tracked every multiplexer selection signal, or DiffuzeRTL, which monitored registers affecting multiplexer signals, ProcessorFuzz focuses on CSRs because they inherently expose the processor's Finite State Machine (FSM) state. Monitoring transitions in CSRs allows the fuzzer to identify "interesting" hardware events, such as changes in privilege level or the occurrence of floating-point mode exceptions, which are indicative of deeper functional behavior. This approach avoids the misleading coverage often generated by data path registers, which can change frequently due to routine data operations without revealing new architectural states.
The design of ProcessorFuzz integrates an Instruction Set Architecture (ISA) simulator into its fuzzing loop. This is a critical architectural decision as ISA simulators are roughly 100x faster than RTL simulators. The fuzzing process begins with a seed corpus of inputs. New inputs are generated and first executed on the ISA simulator. The ISA trace log is then monitored for new CSR transitions. Only if a new, interesting CSR transition is observed does the system trigger a more resource-intensive RTL simulation. This two-stage approach dramatically accelerates the discovery of interesting inputs and potential bugs. The RTL simulation then compares its trace log with the ISA simulation's log to identify discrepancies, which may indicate a bug. A significant advantage is that ISA simulation-based feedback requires almost no hardware-specific RTL instrumentation, making it easily adaptable to different processors sharing the same ISA.
The efficacy of ProcessorFuzz was evaluated on three real-world open-source processors: Rocket Core and Boom Core (both Chisel-based), and Blackbird Core (SystemVerilog-based). The Spike and Ramos ISA simulators were used. When compared against NorCal (a random instruction generator) and DiffuzeRTL (with register guidance) over 44 hours and 10 repetitions, ProcessorFuzz demonstrated superior bug discovery rates. For known bugs, it achieved 1.21x and 1.23x speedups respectively. While ProcessorFuzz sometimes achieved lower overall register coverage, its targeted CSR transition coverage proved more effective for actual bug discovery, highlighting that "higher coverage doesn't necessarily translate to faster bug discovery if your coverage metric is not well suited to fuzzing." The research ultimately identified eight new functional bugs across these processors, some even revealing inconsistencies between the ISA simulator and RTL implementation, such as in the Blackbird Mojo core.
Targeted Bitstream Fault Fuzzing - Accelerating BiFI on Large Designs
This work addresses the impracticality of brute-force Bitstream Fault Injection (BiFI) attacks on modern, large-scale FPGAs. The objective is to automatically identify specific Lookup Tables (LUTs) within an FPGA's bitstream that, when manipulated, can induce a critical fault, such as skipping rounds in an AES cipher. The attack methodology consists of four main steps:
- Bitstream Extraction and Conversion: The proprietary FPGA bitstream, typically stored in non-volatile memory, is extracted. Open-source tools from Project X-Ray are then used to convert this bitstream into a human-readable FASM (FPGA Assembly) format. The FASM file provides a detailed representation of each basic element, including the Boolean function of individual LUTs (e.g.,
D Lut in slice X12Y112). This FASM file is further converted into a Verilog netlist.
- Vulnerable LUT Identification: This is the core contribution. The Verilog netlist is fed into HAL, an open-source gate-level netlist analyzer designed for reverse engineering. Within HAL, the Dana algorithm is employed to group individual flip-flops into higher-level Word-level registers (e.g., 128-bit registers common in AES designs). The researchers observed that in AES designs, the done signal (which controls the round counter) is often connected to the clock enable signal of the last round's register. By tracing back from this 128-bit register's clock enable signal, they can pinpoint the specific LUT(s) responsible for computing the done signal. Manipulating this LUT can effectively skip AES rounds, allowing for key recovery. This process significantly reduces the number of potential attack points from millions of LUTs to a small, manageable set.
- Bitstream Manipulation: Once the target LUTs are identified, a custom manipulation tool, again built upon the FASM format, is used to alter the bitstream at the exact locations corresponding to these LUTs. This avoids the need for time-consuming re-synthesis of the entire design. A collection of modified bitstreams is generated, each with a different fault injected into a target LUT.
- Fault Injection and Key Leakage: The manipulated bitstreams are loaded onto the FPGA. The AES cipher is then queried, and the resulting faulty ciphertexts are analyzed. With a successful fault (e.g., a skipped round), the cryptographic key can often be recovered using established cryptanalysis techniques.
Case studies were performed on Xilinx 7 Series devices using 11 open-source AES designs from the original BiFI paper. Nine of these designs were successfully attacked. The methodology reduced the target attack points from 550-1600 LUTs per design to only 1-3 target LUTs. This translated into dramatic speedups: attack times were reduced from 60-180 hours for brute-force BiFI to just 6-20 minutes using the targeted approach, representing a speedup of up to 1600x. In designs combined with other cores, speedups of over 6000x were observed (reducing 1300 hours to 10-15 minutes). The researchers acknowledge that two designs were not amenable to their current algorithm, suggesting avenues for future work.
EC-CFI: Control-Flow Integrity via Code Encryption Counteracting Fault Attacks
EC-CFI proposes a novel Control-Flow Integrity (CFI) scheme specifically designed to mitigate fault attacks that aim to hijack program execution. The threat model considers an adversary capable of injecting one or multiple faults (e.g., bit flips, stuck-at-zero/one) into the processor. These faults can manipulate instruction encodings, register values, CPU pipelines (like the Address Generation Unit), or instruction parameters, leading to control flow deviations (e.g., jumping from a non-secret function to a secret function). Crucially, the paper highlights that such attacks, once purely local, can now be executed remotely via techniques like VoltJockey, Plundervolt, and ClockScrew, necessitating robust countermeasures.
The core concept of EC-CFI is cryptographic CFI. Before program execution, each function in the program is encrypted with a dedicated, unique encryption key. During runtime, the decryption key is dynamically derived. A switch between functions (e.g., from function A to function C) requires that the correct decryption key for function C is in place. If a fault attack causes an unauthorized control flow transfer (e.g., from function C to a secret function), there will be a key mismatch. This mismatch, with a very high probability, will result in a decryption error, leading to the fetching of gobbled instructions and an immediate illegal instruction exception, thereby detecting the attack with minimal latency.
The main challenge is implementing this fine-grained, per-function encryption using existing hardware. The solution leverages Intel's Total Memory Encryption - Multi-Key (TME-MKT) engine, found in modern CPUs like Raptor Lake and Sapphire Rapids. TME-MKT encrypts memory using keys mapped to Key IDs, which are embedded in the upper bits of the physical address. The Key ID is typically set via the page table entry, meaning TME-MKT is inherently page-granular. To achieve fine-grained, per-function encryption, EC-CFI employs a hypervisor and Extended Page Tables (EPTs), which are used in second-level address translation in virtualized environments.
The technique involves establishing separate EPTs for each unique encryption key. While all these EPTs map the same guest physical address to the same host physical address (i.e., the same page frame number), they differ in the Key ID field embedded within their entries. For example, EPT1 might use Key ID 1 (blue key), and EPT2 might use Key ID 2 (green key). By dynamically switching between these EPTs, different encryption keys can be applied to the same memory region. The VMFUNC instruction, a virtualization technology instruction, is used to rapidly switch between EPTs.
At compile time, an LLVM toolchain is modified to assign a dedicated EPT pointer (and thus an encryption key) to each function. A custom loader then loads code blocks into memory, dynamically switching EPTs to encrypt each block with its assigned key. At runtime, a global register (R) stores the current EPT pointer. Before a function call, the correct EPT pointer for the target function is derived (by adding a position-dependent constant to R), and the VMFUNC instruction is called to activate the corresponding EPT. If a fault attack causes an incorrect jump, the active EPT's key will not match the target code's encryption key, leading to a decryption error and an illegal instruction.
The proof-of-concept implementation involved the modified LLVM toolchain, a loader, and a hypervisor. While the security analysis confirmed the effectiveness against fault attacks by immediately detecting control flow manipulations via illegal instructions, the initial performance overhead was significant—a factor of six on SPEC and M-bench benchmarks. This high overhead was attributed to a massive increase in TLB (Translation Lookaside Buffer) pressure. To address this, the authors proposed a minimal hardware modification: introducing a Key ID register (similar to Intel's PKRU register) that would allow the TME-MKT engine to fetch the Key ID from a register instead of the physical address. Emulation of this modification showed a drastically reduced overhead of 1.21x, making the cryptographic CFI scheme much more practical.
Demo / Proof of Concept
▶ Watch: EC-CFI: Control-Flow Integrity via Code Encryption (34:28)
Each of the presented papers included a robust proof-of-concept or experimental evaluation to validate their claims.
For ProcessorFuzz, the authors demonstrated its effectiveness by evaluating it on three real-world, open-source processors: Rocket Core, Boom Core (both Chisel-based), and Blackbird Core (SystemVerilog-based). They used Spike and Ramos as ISA simulators. The demonstration involved comparing ProcessorFuzz against a random instruction generator (NorCal) and a register-guidance fuzzer (DiffuzeRTL) over 44 hours, repeated 10 times. The key outcome was the successful identification of eight new functional bugs across these established RISC-V processors, showcasing ProcessorFuzz's ability to uncover previously unknown vulnerabilities in complex, mature designs. This included a bug in the Blackbird Mojo core where the ISA simulator was incorrect while the RTL was correct, highlighting its utility in finding discrepancies across different abstraction levels.
The "Targeted Bitstream Fault Fuzzing" paper's demonstration centered on its application to Xilinx 7 Series FPGAs. The researchers conducted case studies using 11 open-source AES designs derived from the original BiFI paper. They successfully demonstrated the automated identification of vulnerable LUTs in 9 out of 11 designs. The proof-of-concept showed that their TBFF (Targeted Bitstream Fault Fuzzing) attack could reduce the number of required bitstream manipulations from hundreds or thousands to just 1-3 target LUTs per design. This directly translated to practical attack times, with successful key recovery in 6 to 20 minutes for individual AES designs, a stark contrast to the 60 to 180 hours required for brute-force BiFI. Further, combining AES designs with other cores still yielded key recovery in 10 to 15 minutes, demonstrating the method's scalability to larger, more complex designs with speedups exceeding 6000x.
For EC-CFI, the proof-of-concept involved implementing their cryptographic CFI scheme using an LLVM toolchain. This modified toolchain automatically instruments the code to assign dedicated EPT pointers and manage the VMFUNC calls for EPT switching. They also developed a custom loader responsible for loading code blocks into memory with the correct encryption keys and a hypervisor to manage the extended page tables. The system was evaluated by compiling binaries from the SPEC and M-bench benchmark suites and executing them on an Intel CPU. While the initial performance overhead was high (a factor of six), the proof-of-concept successfully demonstrated that the fine-grained memory encryption and CFI mechanism worked as intended, leading to immediate illegal instruction exceptions upon simulated control flow hijacking, thereby validating its security against fault attacks. The subsequent emulation of a proposed hardware modification also provided a proof-of-concept for achieving practical performance.
Defensive Implications
▶ Watch: EC-CFI Q&A: Protecting against fault attacks vs. CET (48:00)
The research presented in this session offers several critical implications for hardware defenders, ranging from improved verification methodologies to robust fault attack countermeasures.
For ProcessorFuzz, the key takeaway for defenders is the urgent need to integrate more sophisticated and targeted fuzzing techniques into their hardware design and verification pipelines. Relying solely on general coverage metrics or random instruction generation is insufficient for uncovering subtle yet critical functional bugs. The CSR transition coverage metric provides a blueprint for developing more intelligent fuzzers that prioritize architectural state changes, leading to faster and more effective bug discovery. Hardware developers should consider adopting similar ISA simulation-driven approaches to accelerate their verification cycles and enhance the security posture of their processors before deployment. Furthermore, the discovery of discrepancies between ISA simulators and RTL implementations underscores the need for continuous cross-verification across different abstraction levels.
"Targeted Bitstream Fault Fuzzing" highlights a significant threat to FPGA-based designs, especially those implementing cryptographic functions. Defenders must recognize that existing bitstream protection mechanisms, such as encryption and authentication (e.g., in Xilinx 7 Series and partially in UltraScale devices), are often broken or insufficient. The ability to automatically pinpoint vulnerable LUTs makes BiFI a practical and potent attack. Countermeasures should focus on:
- Enhanced Bitstream Protection: Investing in more robust, potentially custom, bitstream encryption and authentication schemes that are not easily reverse-engineered.
- LUT Obfuscation: Exploring design techniques that obfuscate the relationship between logical functions and physical LUTs, making it harder for attackers to identify critical components. This could involve dynamic remapping or more complex synthesis strategies.
- Fault Injection Countermeasures: Implementing traditional fault injection defenses at the design level, such as duplication of critical logic, error detection codes, and redundant computations, to detect and react to manipulated LUTs.
- Security-Aware Synthesis: Encouraging FPGA vendors to develop synthesis tools that are aware of security implications and can generate more resilient mappings.
EC-CFI provides a promising new paradigm for protecting against fault attacks, which are increasingly relevant due to remote attack vectors. Defenders should consider implementing cryptographic CFI in critical systems, especially those deployed in untrusted environments like the cloud. While the current implementation leveraging Intel TME-MKT faces performance challenges, the proposed hardware modification (a dedicated Key ID register) offers a clear path towards practical deployment. This suggests that hardware architects should advocate for and integrate features that support fine-grained memory encryption and dynamic key management. For existing systems, the virtualization-based approach, despite its overhead, can still offer a higher level of assurance against fault-induced control flow hijacking, particularly where security is paramount over raw performance. This is a complementary approach to software-based CFI (like Intel CET) as it addresses a different threat model—physical faults rather than purely software-based exploits.
In summary, the session underscores that hardware security requires a multi-faceted approach: rigorous, intelligent verification to eliminate bugs, proactive defense against advanced fault injection techniques, and innovative cryptographic schemes to ensure runtime integrity.
Key Takeaways
- ProcessorFuzz Redefines Hardware Fuzzing: By focusing on Control and Status Register (CSR) transitions and leveraging ISA simulators for rapid feedback, ProcessorFuzz offers a scalable and effective method to find functional bugs in complex processors, demonstrating superior bug discovery rates over traditional coverage metrics.
- Targeted BiFI Makes FPGA Fault Attacks Practical: The ability to automatically identify vulnerable Lookup Tables (LUTs) through reverse engineering tools like Project X-Ray and HAL drastically reduces the attack time for bitstream fault injection (BiFI) on large FPGAs from months to minutes, making this a practical threat.
- Cryptographic CFI Counteracts Fault Attacks: EC-CFI demonstrates a novel approach to Control-Flow Integrity (CFI) using per-function code encryption, providing immediate detection of fault-induced control flow hijacking via decryption key mismatches and illegal instruction exceptions.
- Repurposing Existing Hardware for Security: The EC-CFI work creatively utilizes Intel's TME-MKT and virtualization features (Extended Page Tables,
VMFUNC) to achieve fine-grained memory encryption without requiring new hardware, showcasing ingenuity in leveraging current chip capabilities for advanced security. - Performance vs. Security in Hardware: While the EC-CFI virtualization approach incurs significant performance overhead (factor 6), the proposal for a minimal hardware modification (Key ID register) highlights the critical trade-offs and potential pathways to make such robust security features practical (reducing overhead to 1.21x).
- Hardware Verification and Defense Must Evolve: All three papers collectively emphasize that the increasing complexity and attack surface of modern hardware necessitate continuous innovation in both finding vulnerabilities (fuzzing) and building resilient defenses (targeted countermeasures, cryptographic integrity) against sophisticated adversaries, including those employing remote fault injection.
About the Speaker(s)
The session featured presentations from three key researchers. Sadullah Canakci, a recent PhD graduate from Boston University, presented the work on ProcessorFuzz, focusing on novel hardware fuzzing techniques. Maik Ender, a PhD candidate from Ruhr University Bochum and the Max Planck Institute for Security and Privacy, delivered the talk on Targeted Bitstream Fault Fuzzing, with his research interests encompassing Hardware Trojans, FPGA security, and bitstream security schemes. Lastly, Pascal Nasahl, a PhD candidate from Graz University of Technology, presented the EC-CFI paper, specializing in mitigating various threats through cryptographic computing. The session was chaired by Sohrab Aftabjahani from Intel.
Reviews
Dr. Zero (Offensive Security Researcher) — SOLID
This is a dense, high-yield academic session that actually matters outside a university lab. Ender’s automated bitstream fault targeting is the crown jewel here, dropping FPGA attack times from weeks to minutes using open-source reverse engineering tools. The EC-CFI work is a clever abuse of Intel TME-MKT, even if the massive performance overhead makes it a non-starter without new silicon.
Heather Calloway (CISO) — STRONG ACCEPT
This is an academic hardware security session covering processor fuzzing, FPGA fault injection, and silicon-level control-flow integrity. While outside a standard CISO's daily lane, it highlights a hard truth for enterprise architecture: software defenses cannot patch fundamental silicon vulnerabilities. If your business relies on FPGAs for custom cryptography or processes highly sensitive data in multi-tenant clouds, your engineering teams need to digest this research.
All talks from IEEE International Symposium on Hardware Oriented Security and Trust (HOST) 2023