Car Hacking Hits the Update Channel: What the Android Head-Unit Botnet Teaches Automotive Engineers

car hacking — featured image

The Android head unit in your car just became a trojan horse — and it got there through the same update channel the manufacturer uses.

That’s the short version of the campaign Dark Reading reported this week: operators behind a long-running click-fraud botnet have pivoted to vehicle infotainment modules, abusing legitimate update functionality to plant persistent infections. It is a car hacking story, but not the kind most engineers were expecting. Nobody picked a lock. Nobody spliced into the CAN bus in a parking garage. The malware walked in the front door — the OTA update pipeline — dressed as trusted firmware.

If you build these systems, this is the paragraph where the room usually gets quiet. Because the assumption baked into most automotive software architectures is that the update path is the safe path. That assumption is now the attack, and this incident reframes car hacking as an update-chain problem before it is a physical-access problem.

How Click-Fraud Malware Turned Car Infotainment Into a Botnet Node

The mechanics are more mundane than the headline suggests, which is exactly what makes them dangerous. The head units in question run Android — often a vendor fork stuck several major versions behind mainline, with a bespoke update client bolted on by the OEM or tier-one supplier. That client typically checks a manufacturer-controlled endpoint on some cadence, pulls a signed package, and applies it.

The click-fraud crew doesn’t need to break the signing chain to win. They need to reach the delivery layer. In the reported campaign, that means poisoning the update distribution — compromised mirrors, look-alike domains, aftermarket app stores bundled by grey-market resellers of Chinese-manufactured head units, and in some cases straight man-in-the-middle interception on units that never enforced certificate pinning to begin with.

Once the payload lands, it behaves the way any modern Android malware behaves: persistent service, wake-on-boot, silent network traffic to a C2 for click-fraud instructions, and enough opsec to avoid tanking the user experience so nobody notices. The driver sees infotainment that works. The botnet sees another node. This is the shape car hacking takes when the attacker never touches the car.

The novel part isn’t the malware. It’s the delivery surface. A car’s head unit is a device that lives on a hostile network (cellular, sometimes public Wi-Fi), runs an old Android userland, sits behind a trust boundary the OEM defined years earlier, and — critically — is almost never patched by the user. It is a perfect long-lived botnet host.

The Trust Problem: Why Legitimate Update Channels Are Perfect Trojan Horses

Every offensive researcher who has spent time inside embedded systems has the same private opinion about OTA: it is the fattest attack surface in the vehicle, and it is the one automotive engineers defend the least aggressively.

The reason is cultural, not technical. Update systems are built by the same team that ships features. Features have deadlines. Threat models get written once, at architecture time, and then treated as settled. The document says “packages are signed, therefore the channel is trusted,” and the conversation ends.

But signing is only one property of a trustworthy update. The channel also has to survive:

  • Endpoint substitution — DNS poisoning, BGP hijack, or an aftermarket reseller pointing the client at their own mirror.
  • Downgrade attacks — replaying an older, still-signed, still-vulnerable package. Frameworks like The Update Framework (TUF) exist precisely because signature-only schemes fail this class of attack.
  • Supply-chain compromise upstream of signing — the attacker doesn’t forge a signature, they get their code signed by whoever holds the key.
  • Post-install trust inheritance — the update client runs as system, so anything it installs inherits system, and now your “userspace app” has kernel-adjacent reach.

None of these require breaking cryptography. They require understanding that a signature proves origin, not intent. The click-fraud operators understood that. Most head-unit engineers hadn’t been asked to.

This is the same class of problem we see in IoT firmware and embedded device supply chains — cameras, routers, medical gear, industrial controllers. Automotive isn’t a special case; it’s the latest case. What makes cars uncomfortable is the blast radius: a compromised smart bulb annoys you, a compromised head unit sits inside a two-ton machine on a public road.

What Automotive Engineers Miss When They Don’t Think Like Attackers

The pushback I hear most often from automotive and embedded engineers when we run a session is a version of this: “I build these systems. I don’t need to learn to break them. That’s a red-team job.”

I understand the instinct. It is also the exact instinct the click-fraud crew is monetizing.

Here is what “thinking like an attacker” actually changes about how you design an update mechanism. It stops being a data-transfer problem and starts being an authorization problem. Instead of “how do I get bytes from server to ECU,” the question becomes “what does an attacker gain at each stage of this pipeline if they own the stage before it?” You start pinning certificates because you have watched someone MITM a head unit in a lab. You start enforcing anti-rollback because you have replayed a downgrade yourself and seen it work. You separate the update client’s privileges from the payload’s privileges because you have owned a device by proxy — through its own installer — and you know how cheap that is.

None of this is exotic. It is table-stakes offensive knowledge applied to defensive architecture. The gap isn’t intelligence; it is exposure. Engineers who have never sat on the other side of the wire threat-model differently than engineers who have. That is the core argument for treating car hacking as a builder’s skill, not a red-team specialty.

The recurring theme in the incidents we cover — automotive, IoT, industrial — is that the defender’s imagination is bounded by their own architecture diagrams, and the attacker’s isn’t. Closing that gap is a training problem, not a tooling problem. No amount of SAST or SBOM tooling teaches an engineer to look at their own OTA client and ask, “where would I stand to intercept this, and what would I need to sign to be believed?”

From Defensive Builder to Offensive Thinker: Why Car Hacking Skills Matter Now

The head-unit campaign is not the last one. It is the visible edge of a category. Android-based infotainment is now shipping in enough vehicles, across enough OEMs and enough grey-market aftermarket suppliers, that the target surface is permanent. The next campaign will be quieter. It won’t announce itself with click-fraud traffic; it will sit on the CAN gateway, or it will scrape user data, or it will wait for a payload the operator hasn’t decided on yet. Groups like Auto-ISAC have been signaling this direction for years — the question is whether individual engineering teams are absorbing it.

For anyone designing, integrating, or securing these systems, the shift is clear: offensive skills are no longer optional context for defensive work. They are the defensive work. If you cannot walk your own automotive and embedded attack surface — physically, with a UART cable and a logic analyzer, and remotely, with the same tooling the click-fraud crew is using — you are threat-modeling on someone else’s assumptions.

Start Here: Hands-On Car Hacking

Our Car Hacking Course is built for exactly the engineer this post is written for: the embedded, automotive, or firmware developer who has spent a career on the defensive side and now needs the offensive counterpart. You will pull apart real head units on the bench, not simulate them in a slide deck. You will exploit CAN bus messaging in a lab environment that mirrors what production networks actually look like. You will run the same categories of attack the click-fraud operators are running — MITM against update clients, downgrade replays, payload injection through legitimate installers — so that when you go back to your own architecture on Monday, you see it the way an attacker does. If you own any part of a vehicle’s software stack, this is the fastest path from builder to breaker to better builder.

Not ready to commit to the full Car Hacking Course yet? Grab our free Cybersecurity Career Guide — a short read for engineers mapping out where offensive skills fit into a security trajectory before they pick a specialization.