3.6 MEGAJOULES OF DANGEROUSLY SKIP PERMISSIONS: CAN Reverse Engineering in the Real World
Tristan Steele (Engineer)
[un]prompted.au 2026 · Day 1 · Main Hall
Overview
Tristan Steele's presentation, "3.6 MEGAJOULES OF DANGEROUSLY SKIP PERMISSIONS: CAN Reverse Engineering in the Real World," delves into the fascinating and often perilous intersection of artificial intelligence and real-world hardware. Steele, an engineer with a diverse background, shares his journey of integrating a smart battery into his Home Assistant setup, which unexpectedly led him down the rabbit hole of Controller Area Network (CAN) bus reverse engineering using large language models (LLMs). The talk is a compelling exploration of how LLMs can be leveraged to understand complex, undocumented communication protocols, offering a pragmatic, albeit "dirty hacks," approach to a challenging problem.

Key moments
- 2:00 Connecting smart battery to Home Assistant via CAN bus
- 6:00 Safely connecting LLMs to hardware with real-world risks
- 11:55 LLM extracts battery app telemetry from screen captures
- 14:00 Hardware hacking tips and initial CAN bus listening
- 19:20 Applying nuclear physics to correlate CAN bus data
- 23:00 LLM decodes CAN messages and can-poke for safe writes
- 25:00 Sending dangerous CAN message and embracing imperfect solutions
- 27:20 Q&A: Home Assistant integration and future AI projects
3.6 MEGAJOULES OF DANGEROUSLY SKIP PERMISSIONS: CAN Reverse Engineering in the Real World
Speakers: Tristan Steele, Engineer
Conference: [un]prompted.au
YouTube: https://www.youtube.com/watch?v=kPrMbw4VhQQ
Overview
Tristan Steele's presentation, "3.6 MEGAJOULES OF DANGEROUSLY SKIP PERMISSIONS: CAN Reverse Engineering in the Real World," delves into the fascinating and often perilous intersection of artificial intelligence and real-world hardware. Steele, an engineer with a diverse background, shares his journey of integrating a smart battery into his Home Assistant setup, which unexpectedly led him down the rabbit hole of Controller Area Network (CAN) bus reverse engineering using large language models (LLMs). The talk is a compelling exploration of how LLMs can be leveraged to understand complex, undocumented communication protocols, offering a pragmatic, albeit "dirty hacks," approach to a challenging problem.
The core of Steele's work revolves around enabling an AI agent to interpret a mobile application's user interface and then correlate those observations with raw CAN bus data to decode the underlying messages. This process not only uncovers the battery's operational telemetry but also highlights the critical importance of implementing robust safety barriers when connecting powerful, autonomous agents to physical systems. The talk serves as a vital reminder that while AI offers unprecedented capabilities for automation and discovery, its deployment in environments with real-world consequences demands meticulous attention to security, permissions, and the potential for unintended side effects.
This presentation is highly relevant for security professionals, hardware hackers, and anyone interested in the practical applications and inherent risks of integrating AI with embedded systems. It demystifies the process of CAN bus analysis, demonstrates the surprising efficacy of LLMs in interpreting visual and raw data, and, most importantly, provides actionable insights into how to approach such projects safely and responsibly, preventing an enthusiastic AI from inadvertently causing a "lithium battery fire starter" incident.
Background
▶ Watch: Connecting smart battery to Home Assistant via CAN bus (2:00)
Tristan Steele's journey began with a common hobbyist's desire: integrating a recently purchased smart battery into his Home Assistant ecosystem. While an unofficial Bluetooth add-on existed, Steele harbored "trust issues" with wireless communication for critical systems and found the "too easy" solution unsatisfying. His curiosity led him to an undocumented accessory interface on the battery, featuring six pins. A quick online search revealed that two of these pins constituted a CAN bus.
The Controller Area Network (CAN) is a message-based protocol designed for robust, decentralized communication between multiple devices (nodes) on the same wires. Unlike address-based networks, CAN messages carry information about their payload, allowing any node to accept any message it cares about. It's a multi-master bus with a unique collision resolution mechanism that prioritizes messages without data corruption. Furthermore, CAN incorporates fault confinement, where misbehaving nodes automatically demote themselves, enhancing reliability. These features have made CAN ubiquitous in modern vehicles (often with multiple buses for different subsystems), industrial control systems, robotics, 3D printers, and, as Steele discovered, smart batteries.
Steele's primary goal was simply to monitor his battery's charge status, but he quickly recognized the broader implications for reverse engineering and troubleshooting. He cited a SecTor 2025 talk on using CAN bus reverse engineering for vehicle modifications, underscoring the protocol's widespread application. The fundamental challenge was that while he didn't fully understand the CAN bus, he believed an AI could. His plan was to connect the battery to an AI, but this presented two immediate problems: the AI couldn't interpret the battery's companion app, and it couldn't directly communicate over CAN. This set the stage for a deep dive into using AI to bridge these gaps, all while navigating the significant safety risks associated with connecting an LLM to a high-power lithium battery. The concern wasn't just about data, but about preventing the LLM from becoming "blissfully unaware of its consequences" when interacting with real, potentially dangerous, machinery.
Key Findings
▶ Watch: LLM extracts battery app telemetry from screen captures (11:55)
Steele's exploration yielded several significant findings regarding the practical application of LLMs in hardware reverse engineering:
- Effective UI Interpretation by LLMs: LLMs, particularly Claude Haiku and later Opus, demonstrated a surprising ability to accurately interpret changes in a mobile application's user interface from a stream of screenshots. By feeding pairs of images to the model, it could reliably identify changes in telemetry, button states, and mode selections, effectively translating visual information into structured data. This capability significantly streamlines the initial data collection phase for understanding device behavior.
- Statistical Correlation for CAN Bus Analysis: A novel approach inspired by nuclear physics, focusing on "coincidences," proved highly effective for identifying relationships within vast amounts of raw CAN bus data. By analyzing the time differences between occurrences of different message IDs, Steele could generate a correlation matrix that immediately highlighted dependencies and patterns that would be nearly impossible to discern through manual inspection or simple string matching. This technique transformed 200MB of ASCII data (or 4 million messages over 3 hours) into an actionable visual representation in just five seconds.
- LLMs Decode Undocumented Protocols and Hidden Telemetry: When provided with the processed visual and CAN bus data, along with context and tool descriptions, the LLM (Opus) successfully decoded the battery's extended state messages on the CAN bus. Crucially, it was able to annotate the fields, assess its confidence in the deductions, and even expose telemetry messages that were not visible or accessible through the manufacturer's official UI. This demonstrates the LLM's capacity for inferring complex protocol structures from indirect evidence.
- The Necessity of Safety Barriers and "Harnesses": A paramount finding was the critical importance of designing robust safety mechanisms and "harnesses" around LLMs interacting with real-world hardware. Steele stressed that permissions must reside outside the LLM itself, using isolation options like process ownership, separation, and immutable configurations. The
can-poketool, designed for controlled CAN transmission, exemplifies this by enforcing hard bounds on message IDs and payloads via an external configuration file and a remote daemon, preventing the LLM from arbitrary actions.
- "Dirty Hacks" and Imperfect Solutions are Powerful: Despite the project being a "collection of dirty hacks" and relying on "imperfect" data (e.g., dropped frames, animations causing false positives), the combined approach empowered the AI agent to efficiently achieve its goal. This finding underscores that practical, incrementally developed solutions, even with limitations, can be highly valuable, provided downstream agents are aware of data imperfections.
Technical Deep Dive
▶ Watch: Applying nuclear physics to correlate CAN bus data (19:20)
Steele's technical methodology involved a multi-pronged approach to bridge the gap between human-understandable app interactions and raw CAN bus data, leveraging LLMs at key stages.
The initial challenge was to allow the AI to "see" what the human app user was doing. This was achieved using an HDMI capture setup. A real phone running the battery's app was plumbed into a computer via a USB frame grabber. A standalone Python script captured frames off the handset at approximately five frames per second. To manage the volume of visual data, the script performed a basic threshold calculation to determine if an image had significantly changed. If a change was detected, a pair of images (before and after) was fed into the Claude SDK (initially using Claude Haiku). The LLM's responses, detailing identified changes, were saved as Markdown sidecar files. This process, tested over several minutes, yielded 116 frames, with about 20% dropped as duplicates (often due to app animations that didn't convey meaningful data changes). The latency from event detection to Markdown generation was impressively under five seconds, and the cost was negligible ("less than a Macca's ice cream cone"). Steele also noted that by informing the model about the schema of an intended tool call, the LLM could be guided to produce compliant, structured responses, aiding in data ingestion and grouping. For example, over seven minutes and 2,000 raw frames, the system grouped data into 17 distinct "events" (e.g., navigating a menu to change a setting), substantially improving the signal-to-noise ratio.
Connecting to the CAN bus involved physical hardware. Steele emphasized the importance of heat shrink for reliable connections and 3D-printed harnesses to secure wires and prevent inadvertent shorts. For CAN communication, a Universal Serial Bus (USB) to CAN adapter was used. Crucially, due to the inherent risks, the initial connection to the bus was made in listen-only mode. While low-cost adapters often lack a hardware switch for this, Steele implemented software control. Initial passive listening yielded limited distinct payloads, suggesting the battery was "screaming into the void" without acknowledgment. This necessitated a shift to an active mode where the system would transmit to acknowledge packets, introducing immediate safety concerns. Even with active listening, the data remained sparse until a known accessory – a vehicle charger – was connected. This significantly increased bus activity, revealing 95 IDs and a vast number of distinct payloads.
With a large volume of raw CAN data (e.g., 200 MB of ASCII data from a single capture, or 1 GB over a few days), simple string matching was impractical. Steele developed a system centered around can-watch. Raw CAN bus data was first dumped to disk using candump and then streamed into a local Parquet file cache. can-watch, an MCP (Model Context Protocol) server, queried this cache. The core innovation here was inspired by nuclear physics: looking for coincidences. For every message A, the system recorded the time until the next message B, across all message IDs. Statistical analysis of these time differences revealed three patterns: strong correlation (tight peak), no correlation (random), or bursty behavior. This data was visualized as a matrix view, where darker colors indicated less correlation between message IDs. This matrix, capable of processing four million CAN messages in about five seconds, provided strong hints to the LLM about relationships between messages.
Concurrently, an MCP interface called hdmi-watch was implemented for the HDMI capture data, providing queries for key events, summaries, and raw images. Finally, with can-watch and hdmi-watch providing structured context, an Opus LLM model was set "free to its context's desires." The LLM successfully decoded the extended state messages on the CAN bus, providing annotations, confidence levels, and even uncovering messages not exposed in the app's UI, demonstrating its powerful deductive capabilities.
For transmitting data, Steele developed can-poke, a separate, inherently safe tool. Running as a remote daemon on a Raspberry Pi, can-poke enforced strict permissions through external firewalls and a configuration file that defined hard bounds on permissible message IDs, payloads, and baud rates. If the configuration file's ownership or permissions were incorrect, the daemon would not start. This allowed for controlled experimentation, such as sending a "minus one watt" (interpreted as 65 kilowatts) power draw message, highlighting how easily invalid data could be injected. This comprehensive technical setup allowed Steele to query his battery's charge status, current, and charger control loop data without relying on the cloud or manufacturer's app.
Demo / Proof of Concept
▶ Watch: LLM decodes CAN messages and can-poke for safe writes (23:00)
The entire talk serves as a comprehensive demonstration and proof of concept for using LLMs to reverse engineer real-world hardware interfaces. Steele walked the audience through the full pipeline, from capturing UI data to decoding complex CAN bus messages.
The initial proof of concept involved feeding pairs of screenshots from the battery's mobile app into Claude Haiku. The LLM successfully identified changes in battery telemetry, mode selections, and button states, demonstrating its ability to interpret visual context. This was further refined into a system that could process thousands of frames, grouping them into meaningful "events" for the LLM's consumption.
The core demonstration of CAN bus reverse engineering was the use of the can-watch tool. Steele showed how raw candump output, initially overwhelming, could be transformed into a visually interpretable correlation matrix using statistical analysis. This matrix, calculated rapidly even for millions of messages, highlighted relationships between message IDs, effectively pointing the LLM towards relevant data streams.
The ultimate proof of concept was the LLM's ability to decode undocumented CAN bus messages. By providing an Opus model with the processed data from both can-watch and hdmi-watch, the LLM successfully identified and annotated the battery's extended state messages, including fields and their likely meanings. Crucially, it was able to deduce the existence and purpose of messages that were not exposed in the manufacturer's mobile application, showcasing the power of AI-driven discovery in black-box systems.
Finally, Steele demonstrated the controlled transmission of CAN messages using his custom can-poke tool. He showed how he could send a message pretending to be a charger, requesting a power draw of "minus one watt," which the battery's system interpreted as 65 kilowatts. This highlighted both the success of controlled transmission and the potential for misinterpretation or malicious input if not properly constrained. The practical outcome was the ability to retrieve the battery's charge status, current, and vehicle charger control loop data independently, fulfilling the original goal of integrating it into Home Assistant without relying on the cloud or the potentially "deceased Danish kings" (referring to Bluetooth).
Defensive Implications
▶ Watch: Q&A: Home Assistant integration and future AI projects (27:20)
Steele's talk carries significant defensive implications for anyone working with embedded systems, IoT devices, and especially when considering the integration of AI agents into these environments.
- Strict Permissions and Isolation for AI Agents: The most critical takeaway is that permissions for an AI agent interacting with hardware must reside outside the agent itself. Steele uses the analogy of a "harness" for a dog: "The lead isn't held by the dog." This means leveraging operating system features like process ownership, process separation, and immutable configurations. A "deny by default" policy, similar to a firewall, should be implemented, explicitly listing what is permitted rather than what is forbidden. If an AI can modify its own restraints, no security has been achieved; one has merely "asked nicely."
- Granular Filtering Beyond Message IDs: For bus protocols like CAN, simply filtering by message ID is insufficient. Allowing an ID still permits arbitrary data within its payload. Defenders must consider what content is permissible within those messages and implement checks at a deeper level to prevent malicious or malformed data injection.
- Comprehensive Logging and Audit Trails: As always, logging everything is paramount. An audit log is invaluable for understanding both successful operations and, more importantly, when things go wrong. This provides the necessary visibility for incident response and debugging.
- Sculpting the Blast Radius: Defenders must assume that an AI agent, like a dog, will "chew any cords within reach" and put "any socks on the floor at risk." The blast radius of an agent's actions must be carefully sculpted and contained. This means designing systems with limited scope and impact, especially when dealing with critical infrastructure or high-power devices.
- Leveraging Hardware-Level Safety Features: CAN bus itself incorporates several safety mechanisms. Defenders should ensure these are understood and utilized. This includes initially connecting in receive-only mode (hardware-enabled where possible, or software-gated), understanding dominant timeouts that release transceivers from the wire if they transmit too long, and relying on silicon-layer error counters that automatically remove misbehaving nodes.
- Don't Trust Bus Data Implicitly: Steele's anecdote about sending "-1 watt" (interpreted as 65kW) highlights a critical vulnerability: many application developers and web gateways "always assume that the data coming off the CAN bus is perfectly trustworthy and valid." This is a dangerous assumption. All data originating from a CAN bus, especially in mixed-trust environments, must be validated and sanitized before being processed by higher-level applications or systems.
- Proactive Agent Plumbing and Context Management: Even with "cheap computers" and "dirty hacks," thought must be given to the problem. Agents should not be asked to do something a human wouldn't. Existing safety mechanisms should be proactively integrated into the agent's "plumbing." Furthermore, recognizing that "a solution that's not perfect is still likely useful" means informing downstream agents about the quality and potential imperfections of the data they receive, preventing them from treating it as infallible "ground truth."
Key Takeaways
- LLMs are powerful tools for hardware reverse engineering: They can effectively interpret diverse data sources (visual UI, raw bus data) to decode complex, undocumented protocols and even uncover hidden functionalities.
- Safety is paramount when integrating AI with hardware: Implement robust external safety barriers, strict permissions (deny by default), process isolation, and immutable configurations to contain the AI's actions and sculpt its blast radius.
- Smart data pre-processing enhances LLM effectiveness: Techniques like statistical correlation (e.g., "looking for coincidences" in CAN data) can transform overwhelming raw data into actionable insights, significantly improving the LLM's ability to find patterns and make deductions.
- "Dirty hacks" and imperfect solutions can be highly valuable: Practical, iterative approaches, even with acknowledged limitations, can yield significant results and empower AI agents to achieve complex outcomes efficiently.
- Never implicitly trust data from a CAN bus: Applications and gateways must validate all incoming CAN bus data, as malicious or malformed inputs can have severe real-world consequences.
- Hardware reverse engineering is accessible and manageable: With the right tools, methodologies, and a focus on safety, even complex hardware interfaces like CAN buses can be explored and understood, empowering a broader range of engineers and security researchers.
About the Speaker(s)
Tristan Steele is an engineer whose professional background spans physics, hardware, and software. He describes himself as not an "AI guru," but rather someone who uses AI as a tool to solve interesting technical problems. Steele is known for his passion for hobby projects, particularly those involving the Home Assistant ecosystem, which he views as an "excellent multiplier" for his capabilities and volume of projects. His work often blurs the lines between his professional and personal interests, leading him to explore challenging integrations like the smart battery CAN bus. He champions a pragmatic, hands-on approach, often involving "poking things with soldering irons," and seeks to make complex technical challenges more approachable, even with "dirty hacks."
Reviews
Dr. Zero (Offensive Security Researcher) — SOLID
Tristan Steele wanted to monitor his smart battery and ended up building a highly effective LLM pipeline for CAN bus reverse engineering. He used HDMI capture and statistical time-correlation to feed Claude Opus just enough context to decode undocumented payloads, while enforcing strict hardware-level safety harnesses. It's a hobbyist target, but a masterclass in bounding AI blast radii.
Heather Calloway (CISO) — SOLID
This is a practitioner's proof-of-concept for using LLMs to reverse-engineer hardware, but the enterprise value is purely architectural. The speaker demonstrates exactly why autonomous AI agents interacting with physical systems require immutable, external guardrails. Send this to your product security and OT engineering leads if they are exploring AI-driven automation.