IoT Security Vulnerabilities: What the Android Car Malware Story Teaches Beginners

When Kaspersky disclosed in August 2026 that malware was spreading through the built-in updaters of Android-based car head units built by DoFun, most coverage framed it as a car story. It isn’t. It’s an IoT security vulnerabilities story wearing a dashboard, and it happens to be one of the best beginner-friendly case studies to land in months. If you’ve ever asked where do I start with IoT hacking, this incident is the answer sitting in a million driveways.
The device in your car’s dashboard runs the same class of embedded operating system, the same kind of over-the-air update pipeline, and the same network stack as the smart plug you never thought to firewall. The attackers who compromised those head units didn’t invent new tradecraft. They exploited the three IoT security vulnerabilities patterns that show up in almost every investigation you’ll ever run.
Let’s walk through what happened, why a car screen is an IoT device in the first place, and how you’d start pulling one apart on your bench.
What Happened: Malware in Your Car’s Dashboard
Kaspersky first identified the campaign in June 2026 and The Hacker News published details in August 2026. The malware family targets Android-based vehicle head unit firmware built by DoFun, a supplier whose stack ships inside a range of aftermarket and OEM infotainment systems.
The attack chain is worth reading slowly:
- The malware arrives through the head unit’s built-in updater — the same mechanism drivers trust to keep their maps and media apps current.
- Once resident, it pulls down a multi-stage downloader.
- The downloader deploys two payloads: an ad-fraud module that generates fake impressions and clicks, and a proxy module that enrols the head unit into a botnet, renting the car’s internet connection out to whoever’s paying.
No exotic zero-day. No physical access. Just a trusted update path and a device most owners forget is a computer. Kaspersky’s Securelist research portal is a good place to track how this and similar embedded-device campaigns evolve.
Why Your Infotainment System Is an IoT Device (And What That Actually Means)
Beginners often picture “IoT” as smart bulbs and doorbell cameras. That mental model is too narrow, and it’s exactly what makes stories like this land as a surprise. IoT security vulnerabilities live wherever those four properties overlap — and a modern car head unit ticks every box:
- Embedded operating system. DoFun’s stack is Android, but stripped down and customised — think Android Automotive or AOSP forks running on ARM SoCs. It’s Linux underneath, with the same package management, service model, and root filesystem quirks you’d find in a Raspberry Pi appliance.
- Network connectivity. The head unit talks to your phone over Bluetooth, to Wi-Fi networks in your driveway and workplace, and increasingly directly to cellular networks through the car’s telematics module. Every one of those is an attack surface. The OWASP IoT Top 10 catalogues the recurring weaknesses across exactly these surfaces.
- Over-the-air update mechanism. Firmware and app updates arrive from a vendor-controlled server, are verified (in theory) by signature, and are applied without user consent beyond a splash screen. Compromise the server, weaken the signature checks, or ship a rogue update package and you own the fleet.
- Long lifecycle, weak patching. Cars live a decade. The Android version in the dashboard often doesn’t. Devices that would have been retired years ago in the phone world stay in service, unpatched.
Once you internalise those four properties, the car story stops being unusual. It’s the same shape as the C0xmo botnet lessons we broke down recently — a different device class, same underlying weaknesses.
The Three IoT Security Vulnerabilities Beginners Need to Recognise
Almost every IoT compromise you’ll investigate maps to one of three patterns. The DoFun campaign hit all three.
1. Supply-chain update poisoning
The malware rode in on the legitimate updater. Whether the compromise happened at the vendor’s build server, in a package repository, or through a hijacked update endpoint is a detail; the pattern is that a trusted channel was used to deliver untrusted code. This is the same pattern behind poisoned NPM packages, tampered vendor firmware bundles, and rogue OTA endpoints in industrial devices. When you audit an IoT device, one of the first questions is: how does new code get onto this thing, and who can push it?
2. Firmware persistence
Once the malware landed, it survived reboots, factory resets in some cases, and everyday driving. That persistence lives in the firmware layer — either in system partitions the user can’t wipe or in components that get restored from a compromised recovery image. Understanding how a device boots, where its root filesystem lives, and which partitions are writable is the skill that separates “I ran an nmap” from “I actually understand this device.” Our recent post on firmware analysis and kernel lock-in walks through exactly this territory.
3. Network re-purposing
The endgame wasn’t stealing your Spotify history. It was renting your car’s IP address. Proxy botnets are the quiet business model of modern IoT security vulnerabilities: turn a million low-value devices into a residential proxy network, sell access to fraud operators and scrapers. Every IoT device you own with an outbound internet connection is a candidate for this pattern. When you triage a suspicious device, look at what it’s talking to, not just what’s talking to it.
How You’d Start Investigating This on Real Hardware
If the DoFun story made you want to actually look inside a device instead of reading about one, here’s the honest path from armchair to bench. You do not need a car. You need a device that shares the same architecture.
Pick something cheap and Android-based — a knock-off Android tablet, a discontinued Android TV box, a $40 aftermarket head unit off a marketplace. The methodology is identical:
- External recon. Photograph the board. Identify the SoC, the flash chip, the connectors. Look for a UART header — those unpopulated four-pin patterns near the SoC are almost always a serial console waiting to be soldered.
- Firmware acquisition. Pull the firmware two ways. First, the easy way: download the vendor’s OTA package and unpack it. Second, the honest way: dump the flash chip directly with a cheap programmer. Compare the two. Differences between what the vendor ships and what’s actually on your device are often the entire finding.
- Static analysis. Extract the filesystem. Read
init.rc, list the services, find the updater binary, dump the strings, find the update URL. That URL is often the whole attack surface for a supply-chain compromise. - Dynamic analysis. Boot the device, get a shell (UART, ADB over USB, or ADB over Wi-Fi), and watch what it does. What does it phone home to? Does it verify TLS certificates? Does the updater accept a redirected endpoint? An intercepting proxy in front of a device you own answers most of those questions in an afternoon.
- Report the pattern, not the bug. When you find something, the interesting output isn’t “this device has CVE-shaped hole X.” It’s “this class of device has update-chain weakness Y, and here’s how to check for it on similar hardware.” That’s the mindset that turns you from a bug-hunter into a researcher.
None of the above requires exotic equipment. A soldering iron, a $15 flash programmer, a $20 USB-to-serial adapter, a laptop, and a lab network you don’t mind isolating are the whole starter kit. If you want a structured way through it — with the toolchain, the target devices, and the teardown methodology laid out — that’s exactly what our hands-on IoT hacking course is built around. The broader Lufsec course catalog covers the surrounding disciplines when you’re ready to go wider.
Start With What You Can Hold
The DoFun campaign will fade from the news cycle in a week. The pattern of IoT security vulnerabilities it demonstrates — trusted update channel, firmware persistence, device repurposed as a proxy — will show up in the next IoT story, and the one after that, and the one after that. The point of studying this incident isn’t to remember the vendor name. It’s to recognise the shape so quickly that when a similar story breaks about a smart TV, a solar inverter, or a hospital pump, you already know which questions to ask and which tools to reach for.
Cars, tablets, doorbells, dashboards. Same computer. Same three patterns. Different plastic.
Where to Start When You’ve Never Torn One Down
If you’ve read this far and you’re still stuck on the “where do I start” question, the honest answer is: start smaller than a car, but start with real hardware. Reading about IoT security vulnerabilities is a warm-up; teardown work is the actual muscle.
Our free Intro to IoT Hacking is built for the reader this post was written for — the beginner who understands the concepts but hasn’t yet picked up a device and started pulling it apart. It walks through the same investigation loop we just outlined — external recon, firmware acquisition, static analysis, live traffic — on devices you can buy for the price of a decent dinner. No car required. When you’re done, the next DoFun-shaped headline won’t read like news. It’ll read like homework you’ve already done.



