Fault Injection Attacks on Secure Automotive Bootloaders
Nils Weiss (dissecto GmbH), Enrico Pozzobon (Automotive Penetration Tester)
TROOPERS23 · Day 2 · Track 3
Overview
In this highly anticipated TROOPERS talk, Nils Weiss and Enrico Pozzobon from dissecto GmbH unveiled a novel and practical approach to performing fault injection attacks on secure automotive bootloaders. The presentation highlighted the critical vulnerabilities that exist even in "ultra-reliable" microcontrollers designed for the demanding automotive environment. The speakers demonstrated how electromagnetic fault injection (EMFI) could be leveraged to achieve arbitrary code execution on a PowerPC-based Gateway ECU, a central trust anchor in modern vehicle networks. This research is particularly significant because it challenges the conventional understanding of hardware security in automotive systems, demonstrating a black-box attack that requires no prior reverse engineering of the target firmware.

Key moments
- 3:15 Live demo success: Code execution & firmware dump
- 10:00 Understanding the UDS automotive bootloader update process
- 17:00 Key parameters for electromagnetic fault injection attacks
- 25:00 Efficiently finding fault parameters with an evolutionary algorithm
- 40:00 Post-exploitation: Memory dump, JTAG unlock, custom firmware
- 42:30 Mitigations and call for UDS protocol revision
- 50:50 Q&A: Why automotive ECUs lack standard security features
Fault Injection Attacks on Secure Automotive Bootloaders
Speakers: Nils Weiss (dissecto GmbH); Enrico Pozzobon (Automotive Penetration Tester)
Conference: TROOPERS
YouTube: https://www.youtube.com/watch?v=kKbJhe2MLZY
Overview
In this highly anticipated TROOPERS talk, Nils Weiss and Enrico Pozzobon from dissecto GmbH unveiled a novel and practical approach to performing fault injection attacks on secure automotive bootloaders. The presentation highlighted the critical vulnerabilities that exist even in "ultra-reliable" microcontrollers designed for the demanding automotive environment. The speakers demonstrated how electromagnetic fault injection (EMFI) could be leveraged to achieve arbitrary code execution on a PowerPC-based Gateway ECU, a central trust anchor in modern vehicle networks. This research is particularly significant because it challenges the conventional understanding of hardware security in automotive systems, demonstrating a black-box attack that requires no prior reverse engineering of the target firmware.
The core motivation behind such attacks stems from the evolving threat landscape in the automotive sector. Beyond traditional vehicle theft, attackers are increasingly interested in bypassing immobilizers for resale, making ECUs "virgin" again for aftermarket sales, enabling chip tuning, manipulating mileage, or even circumventing new regulations like AdBlue or e-fuel detection. By gaining control over a Gateway ECU, an attacker can potentially access or compromise numerous other vehicle systems. The talk's impact was underscored by a live demonstration that, despite its non-deterministic nature, successfully achieved code execution and initiated a firmware dump early in the presentation, validating the real-world applicability of their findings.
Background
▶ Watch: Live demo success: Code execution & firmware dump (3:15)
The automotive industry relies heavily on Electronic Control Units (ECUs), which are designed for high reliability against environmental factors like temperature, voltage fluctuations, and electromagnetic radiation. Paradoxically, this robustness makes them ideal targets for fault injection attacks, as they can withstand repeated glitching attempts without permanent hardware damage, unlike more fragile consumer electronics. Automotive microcontrollers, often based on architectures like PowerPC or ARM, also come with a higher price tag, reflecting their specialized nature and stringent quality requirements.
Prior research in fault injection has explored similar avenues. Riscure's "Safety is not equal to Security" demonstrated manipulation of DCF records on comparable processors. Flynn's "Bam Bam" paper detailed attacks on internal bootloaders to bypass authentication. Nassal and Timurs glitched an AUTOSAR-based demonstration ECU. However, a crucial distinction in Weiss and Pozzobon's work is the focus on PowerPC architecture on a real ECU, rather than a demo unit, and achieving full code execution. Previous ARM-based fault injection techniques often exploited the fact that the program counter (PC) is encoded similarly to general-purpose registers (e.g., flipping R7 to PC in memcpy), allowing for "wild jumps" to attacker-controlled payloads without prior firmware knowledge. PowerPC, however, presents a greater challenge as the program counter is a special register, rarely accessed by general instructions, making direct PC manipulation via bit flips significantly harder.
The problem this research addresses stems from the standardized Unified Diagnostic Services (UDS) protocol (ISO 14229), which defines how ECUs are configured, diagnosed, and flashed. While UDS outlines a standard flashing procedure—involving entering a programming session, security access authentication, writing a fingerprint, erasing memory, transferring new data, and finally signature verification—it also introduces a critical vulnerability: the ability to write large portions of flash memory with unverified data before signature verification. This design flaw allows an attacker to inject a malicious payload into the flash, then use fault injection to bypass the subsequent signature check, forcing the bootloader to execute the unverified, attacker-controlled code. Bypassing security access, a prerequisite for erasing and transferring firmware, can often be achieved through publicly available GitHub repositories (e.g., for Volkswagen or Daimler ECUs) or by exploiting cracks of OEM repair shop tester tools, where legitimate firmware can be swapped with an exploit payload.
Key Findings
▶ Watch: Key parameters for electromagnetic fault injection attacks (17:00)
The talk presented several critical findings that advance the state of the art in automotive security:
- Practical Code Execution on PowerPC ECUs: The researchers successfully demonstrated arbitrary code execution on a PowerPC-based automotive Gateway ECU using electromagnetic fault injection (EMFI). This is a significant achievement, as PowerPC architectures were previously considered more resilient to direct program counter manipulation via fault injection compared to ARM.
- Black-Box Attack without Reverse Engineering: A pivotal finding is that the attack does not require prior reverse engineering of the target firmware. By leveraging specific feedback channels and a sophisticated search algorithm, the attack can be performed effectively in a black-box scenario, making it highly scalable and portable across different ECUs.
- Novel Fault Injection Search Algorithm: The team developed and presented an evolutionary algorithm for efficiently searching the vast parameter space of fault injection. This algorithm uses the ECU's exception syndrome register (ESR) and other interrupt vector information as a feedback mechanism to guide the search, drastically reducing the time required to find effective glitch parameters from weeks to mere hours.
- UDS Protocol Vulnerability: The research exposes a fundamental design weakness in the UDS (ISO 14229) software update process. The protocol's allowance for writing large, unverified firmware segments to flash memory before a final signature check creates a critical window of opportunity for fault injection attacks to bypass security mechanisms.
- PowerPC Fault Mechanism Elucidation: While not definitively proven due to measurement challenges, the research suggests that the code execution on PowerPC is likely achieved through stack pointer misalignment (R1) and subsequent incorrect link register reads during exception handling, rather than direct program counter bit flips. This provides insight into PowerPC-specific fault injection vulnerabilities.
- High Portability and Automation: The attack methodology was successfully demonstrated on three different gateway ECUs from distinct OEMs, featuring different PowerPC processors and bootloaders. The entire process, including parameter search, can be largely automated, making it a highly reproducible and efficient exploit technique.
- Information Leakage from Black-Box Systems: The researchers showed how fault injection, combined with analysis of stack traces, can be used to trace the execution flow of a black-box system. By plotting link register values against injection time, or searching for known values (e.g., SHA-1 constants), they could infer which functions were executing at specific times, even identifying cryptographic operations without firmware knowledge.
Technical Deep Dive
▶ Watch: Efficiently finding fault parameters with an evolutionary algorithm (25:00)
The attack leverages electromagnetic fault injection (EMFI), a hardware attack technique that introduces transient electromagnetic pulses to disrupt the target's operation. Unlike other methods like voltage or clock glitching, EMFI allows for non-invasive attacks on packaged chips. The success of an EMFI attack hinges on precise control over several parameters, which define the search space:
- Injection Coil Type and Position: The physical EM probe used and its exact XYZ coordinates on the target chip are crucial. A CNC mill is employed to automate this precise positioning.
- Coil Activation Duration: How long the electromagnetic pulse is applied.
- Capacitor Charging Voltage: The energy stored and discharged into the coil, determining the intensity of the fault.
- Offset from Trigger: The delay between a specific event (e.g., a CAN message) and the fault injection.
- Memory State and Environmental Factors: The current state of the ECU's memory and external conditions (temperature, vibrations) can also influence outcomes.
The experimental setup utilized a combination of specialized and off-the-shelf equipment. A ChipSHOUTER (a professional EMFI tool) or a more affordable PicoEMP generates the electromagnetic pulses. A ChipWhisperer (or its cheaper counterpart, Husky) provides precise timing control, delaying the fault injection by nanoseconds after a trigger event. For automation, a CNC mill positions the EM coil, and a Raspberry Pi Pico with a solid-state relay acts as a programmable power supply. Triggering can be done via an FPGA or, for simplicity, directly from the CAN bus. UART communication serves as the primary feedback channel, outputting stack traces and debug messages. The total cost of a fully functional setup can be as low as $300, demonstrating its accessibility.
When a fault is injected, three outcomes are possible:
- Normal Response: No disruption occurred, indicating the fault was too weak or poorly timed.
- Corrupted Response: The CAN peripheral itself was affected, leading to garbled communication.
- ECU Reset with Stack Dump: The most informative outcome, where the ECU crashes and outputs a stack trace via UART. These stack traces are critical, often revealing information like the Exception Syndrome Register (ESR), which indicates the type of exception (e.g., illegal instruction), and addresses like SRR0 (where the exception happened) and the link register (the return address of the previous function). This information is usually hidden in normal operation, making fault injection a powerful debugging tool for black-box systems.
To navigate the vast parameter space, the researchers implemented an evolutionary algorithm. This algorithm operates on a "population" of fault parameter "particles." Initially, parameters are randomized. Each particle is tested, and its outcome (e.g., the resulting stack trace and ESR value) is "rated." "Good" outcomes, particularly those that maximize the variance of observed exceptions or correlate with known "jump to payload" conditions (like an "illegal instruction" exception), are rewarded. Particles with high ratings are multiplied in the population, while those leading to "bad" or no effects are "killed." Slight mutations are introduced to the surviving population, allowing the algorithm to converge on optimal settings. This process dramatically reduces the search time. For example, specific ESR values like "illegal instruction" were found to correlate strongly with successful code execution, allowing the algorithm to prioritize these outcomes.
The payload injected into the ECU's flash memory is designed to be position-independent. Since the exact jump target of a fault is unknown, the payload consists of a large number of NOP sleds (e.g., 113 NOP instructions) surrounding the actual exploit code, repeated thousands of times (e.g., 1000 times before and 2000 times after). This strategy increases the probability that an arbitrary jump will land within a NOP sled, which then slides execution into the exploit code. PowerPC's VLE encoding (Variable Length Encoding) means NOPs are typically 2 bytes, while jumps are 4 bytes, favoring more NOPs to account for unaligned jumps. The exploit code itself can be simple, such as printing "Hello Troopers" and initiating a flash dump.
A common challenge in embedded systems is the hardware watchdog, an external microcontroller that resets the main processor if it becomes unresponsive. During flash dumping, the main CPU might neglect to "pet" the watchdog, leading to a reset. The simple solution demonstrated is to physically cut the watchdog's reset line, allowing for a complete firmware dump. If physical modification is not feasible, software-based watchdog feeding would require prior firmware knowledge. The algorithm's efficiency was quantified, showing an average of 10,000 glitches to find a successful exploit, achievable within minutes to hours at a rate of 5 glitches per second (when coil position changes are minimized).
Beyond code execution, fault injection also provides powerful information leakage capabilities. By correlating specific CAN messages with the values in the link register captured during exceptions, researchers could trace the execution path of a black-box system over time. This technique allowed them to identify when specific functions were executed, or even to detect the use of cryptographic functions (e.g., by observing SHA-1 initialization constants in registers) without any prior knowledge of the firmware.
Regarding the specific mechanism on PowerPC, the researchers hypothesize that the EMFI causes a misalignment of the stack pointer (R1). When an exception occurs and the system attempts to restore the link register from the stack, an incorrect value is read, leading to an arbitrary jump. This differs from ARM's vulnerability where direct program counter manipulation is more common. The extreme electromagnetic forces involved make direct measurement of internal register states during a fault practically impossible.
Demo / Proof of Concept
▶ Watch: Mitigations and call for UDS protocol revision (42:30)
The talk featured a compelling live demonstration that ran continuously throughout the presentation. The speakers had a Gateway ECU mounted in a CNC mill, with an EMFI coil positioned above it, connected to their custom fault injection setup. The system was configured to repeatedly attempt fault injections while monitoring the UART output for signs of success.
Early in the talk, at the 03:30 mark, the live demo successfully achieved code execution. The audience was shown a terminal displaying the message "Hello Troopers 23" originating from the glitched ECU, immediately followed by a partial firmware dump. This live success, despite the inherent non-deterministic nature of fault injection attacks, served as powerful validation of the research's practicality and effectiveness on a real automotive target.
The speakers acknowledged that while this initial success was quick and impactful, their setup was continuously searching for a more robust glitch. Specifically, they aimed to find a fault that would allow for a complete firmware dump without the ECU's hardware watchdog resetting the system. This more advanced scenario would involve hitting a specific core in a multi-core processor such that the other core could keep the watchdog happy. Although this extended goal was not achieved live during the presentation, the initial code execution and partial dump clearly demonstrated the core capability of their technique.
Defensive Implications
▶ Watch: Q&A: Why automotive ECUs lack standard security features (50:50)
The research by Weiss and Pozzobon highlights critical areas where automotive ECU security can be significantly improved. Defenders should consider the following implications:
- Implement Memory Protection Units (MPUs) and Execute-Only Memory: Bootloaders should rigorously enforce write-or-execute (W^X) policies. Flash memory regions containing code should be marked as execute-only and non-writable during runtime, especially after the initial boot process. This would prevent an attacker's injected payload from being executed even if a jump occurs.
- Disable Flash Execution Early: The ability to execute code from flash memory should be disabled as early as possible in the boot process. This minimizes the attack surface and reduces the window during which an attacker can inject and execute malicious code via fault injection.
- Run Bootloader in Hardware Security Module (HSM): Deploying the entire bootloader within a dedicated Hardware Security Module (HSM), which typically has its own isolated flash memory and execution environment, can provide a robust defense. One manufacturer was cited as already implementing this, making their ECUs significantly harder to attack. This separates the bootloader's critical functions from the main processor, even if the latter is compromised.
- Revise UDS Software Update Process: The UDS (ISO 14229) standard's allowance for writing large, unverified firmware segments to flash before a final signature check is a fundamental design flaw. The protocol should be revised to mandate verification of firmware chunks before they are written to non-volatile memory, or to ensure that unverified data cannot be executed.
- Implement Stronger Firmware Encryption: While some ECUs use encrypted firmware, the research noted that existing algorithms (e.g., NRV, XOR pads) often use weak or easily discoverable keys. Moreover, if the bootloader decrypts the firmware before signature verification, an attacker can still inject an encrypted payload that the bootloader will decrypt and execute. Strong, unique, and securely managed encryption keys are paramount, and decryption should ideally occur in a protected environment, with integrity checks before decryption.
- Secure Hardware Watchdog Implementation: While watchdogs are a security feature, attackers might bypass them by cutting lines or finding specific core interactions. Implementations should consider making watchdog bypass more difficult, potentially by integrating them more tightly with the main processor's security features or making physical bypass less straightforward.
- Improve HSM API Security and Documentation: While attackers might gain access to the host processor, they can still interact with the HSM API. While direct key extraction from HSMs remains challenging, the ability to use HSM-protected keys (e.g., for signing operations) still poses a risk. Better security hardening of HSM APIs and, where appropriate, more transparency in their documentation could aid in understanding and mitigating potential abuse.
Key Takeaways
- Fault injection is a practical black-box attack: Electromagnetic fault injection (EMFI) can effectively achieve code execution on real, modern PowerPC-based automotive ECUs without prior firmware reverse engineering.
- PowerPC is not immune: Despite different architectural characteristics compared to ARM, PowerPC processors are vulnerable to fault injection, likely via stack pointer misalignment leading to incorrect link register reads.
- Smart algorithms accelerate attacks: A novel evolutionary algorithm utilizing exception syndrome register (ESR) feedback drastically reduces the time to find effective glitch parameters from weeks to hours, making these attacks highly efficient.
- UDS protocol has critical design flaws: The UDS (ISO 14229) software update process's allowance for writing unverified firmware to flash before signature checks creates a significant vulnerability window for fault injection.
- Mitigations are essential and overdue: Automotive manufacturers should implement robust defenses such as Memory Protection Units (MPUs), running bootloaders within Hardware Security Modules (HSMs), and strong firmware encryption to counter these hardware attacks.
- Information leakage is a secondary benefit: Fault injection can also serve as a powerful tool for tracing execution flow and identifying critical functions (e.g., cryptographic operations) in black-box systems by analyzing stack traces.
About the Speaker(s)
Nils Weiss is associated with dissecto GmbH, a company focused on embedded security. His work, as presented in this talk, demonstrates deep expertise in hardware security, particularly fault injection techniques against automotive systems.
Enrico Pozzobon is an Automotive Penetration Tester, bringing practical experience in assessing the security of vehicle systems. His LinkedIn profile (https://de.linkedin.com/in/epozzobon) further highlights his specialization in automotive security. Together, their combined expertise provided a comprehensive and practical perspective on the vulnerabilities and exploitation of automotive bootloaders.
Reviews
Dr. Zero (Offensive Security Researcher) — MUST SEE
Weiss and Pozzobon didn't just drop theoretical research; they brought a CNC mill on stage and live-glitched a PowerPC Gateway ECU into coughing up its firmware. This is the gold standard for hardware offensive research—turning a black-box EMFI attack into a highly reproducible, automated exploit against a fundamental protocol flaw in UDS. If you build automotive bootloaders and ignore this, you're willfully negligent.
Heather Calloway (CISO) — SOLID
A highly credible technical demonstration proving that a $300 automated fault injection setup can achieve code execution on modern automotive ECUs. The research exposes a structural sequencing flaw in the ISO 14229 (UDS) update protocol, moving physical hardware compromise from a bespoke lab exercise to a repeatable attack. If your business relies on high-value logistics, connected industrial vehicles, or executive fleets, this changes your physical threat model.