Unisoc VoLTE Exploit: Why IoT Firmware Analysis Is No Longer Optional

On August 17, 2026, SSD Secure Disclosure published the second stage of an exploit chain that turns a VoLTE video call into full Android kernel access on devices running Unisoc modem firmware. There is no vendor fix. The first stage — remote code execution inside the modem — was disclosed back in March. The second stage bridges from the modem into the application processor’s kernel. Chain them together and an attacker who can place a VoLTE video call to a target phone owns the device end-to-end. If your IoT firmware analysis practice stops at the Android userland, this chain is exactly the vector you will keep missing — because the initial foothold lives in an operating system most testers never look at.
That sentence should stop every IoT pen tester scrolling past the headline. Not the exposed APIs. Not the Bluetooth stack. The modem’s own OS, running on its own processor, on the same board as the application CPU, whispering to it over IPC that was designed assuming both sides would be trustworthy.
The Unisoc VoLTE chain: when a video call becomes root access
Here is the shape of the chain, without giving anyone a working exploit:
- Stage one (March 2026): A malformed SIP/SDP payload delivered inside a VoLTE video call setup triggers memory corruption inside the Unisoc modem firmware. The attacker gets code execution on the baseband processor. From the phone user’s perspective, nothing rings — this is pre-answer signaling. The mechanics of SIP session setup mean the parser runs before any UI event fires.
- Stage two (August 2026): Code running on the modem abuses the shared memory and IPC channels the modem uses to talk to the Android kernel. A trusted control path becomes an untrusted one. The attacker pivots from baseband RCE to Android kernel primitives — read, write, execute — with no user interaction and no crash the user would notice.
The whole chain is remote, zero-click, and touches nothing the average IoT pen tester is trained to look at. There is no open port on the internet. There is no misconfigured MQTT broker. There is a radio, a chipset, and two operating systems talking to each other over an IPC boundary that was designed assuming the modem side would always be trustworthy.
Why IoT firmware analysis would have caught this — and surface scans didn’t
Consider what a “standard” IoT engagement typically covers: Nmap the device, fuzz the exposed HTTP and MQTT interfaces, dump the Android APKs, look at the Bluetooth stack, maybe sniff the Wi-Fi association. All of that is useful. None of it touches the modem.
Serious IoT firmware analysis starts where those scans stop. The Unisoc bugs live below the layer most testers are equipped to reach. To find them you need to:
- Extract the modem firmware — usually not shipped as a friendly
.imgin the OTA package. Often a signed blob, sometimes only reachable via JTAG or a chipset-specific loader. - Identify the RTOS underneath. Unisoc devices historically ship with a custom real-time OS on the baseband side. It has its own task scheduler, its own memory manager, its own IPC primitives. It is a full operating system that most reports call “the modem firmware” as if it were a driver.
- Map the IPC surface between that RTOS and the Android kernel — which shared memory regions, which mailbox registers, which trust assumptions.
- Reverse the SIP/SDP parsers and codec paths that handle inbound VoLTE traffic, because that is the code executed before the phone rings.
Each of those steps is a discipline. None of them show up in a Nessus report. This is the same theme we walked through in our breakdown of firmware kernel lock-in: the interesting attack surface is usually the one the vendor assumed you would never see. It is also why ENISA’s IoT guidance has, for several revisions now, pushed vendors and assessors to treat every embedded processor as its own trust domain rather than an extension of the application CPU.
What lives inside IoT firmware: the hidden OS beneath the OS
The phrase “IoT device” nudges people toward a single-CPU mental model — one processor, one firmware, one attack surface. Modern chipsets, including the Unisoc line, are the opposite of that. A rigorous IoT firmware analysis workflow has to enumerate every processor on the board, not just the one running Linux.
A typical LTE-capable IoT-class SoC contains, at minimum:
- An application processor running the vendor’s Linux, Android, or RTOS — the OS the user sees.
- A baseband/modem processor running a separate RTOS with its own privileged code, cellular protocol stacks, and DMA access to shared memory.
- A TrustZone / TEE processor or secure enclave running a third code base, usually with signing keys and cryptographic material.
- Peripheral micro-controllers — Wi-Fi coprocessor, sensor hub, audio DSP — each with their own firmware, some with their own tiny OS.
Every one of those is a firmware target. Every one has an IPC boundary to the others. Every one was written under the assumption that its neighbors are trustworthy. Unisoc’s chain is the textbook exploitation of that assumption: compromise the least-scrutinized OS on the board and use its privileged IPC to walk into the one everyone else was auditing.
This is the same pattern we saw in the Cisco SD-WAN firmware CVE-2024-5 analysis and, at a different layer, in the C0xmo botnet post-mortem: the operator who owns the least-monitored layer owns the device.
The Lufsec approach: tearing down real chipsets to map attack surfaces
You cannot learn this from a slide deck. Reading about baseband IPC and reading the actual mailbox register descriptions from a chipset’s confidential-but-leaked docs are two different experiences. Our IoT track is built around that gap, and the IoT firmware analysis module is the spine of it.
Concretely, the lab work moves through:
- Physical teardown. Identify the SoC, the modem, the flash, the debug pads. Read the datasheets you can find; infer the ones you can’t.
- Firmware extraction. Pull the modem blob out of the update package when possible, off the flash chip when not. Understand what’s signed, what’s encrypted, what’s just obfuscated.
- RTOS identification. Recognize the fingerprints of common baseband RTOSes — task tables, exception vectors, scheduler patterns — in raw memory dumps.
- IPC mapping. Trace the shared memory regions, the doorbells, the mailboxes. Enumerate every place the “untrusted” side of the SoC can influence the “trusted” side.
- Parser hunting. Find the code paths — SIP, SDP, RRC, NAS — that handle attacker-controlled bytes before any user interaction, because those are where zero-click chains start.
If you want to see the on-ramp before committing to the full course, our free intro to IoT hacking walks through the mindset with one concrete device teardown. It’s not the full lab, but it’s the shape of it. Practitioners moving between embedded targets often pair it with the broader Lufsec course catalog to line up hardware-adjacent tracks.
Moving past surface-level IoT pen testing
The Unisoc advisory landed with no vendor fix. That means a lot of shipped hardware is going to stay vulnerable — cheap Android phones, IoT gateways, cellular-connected industrial devices, in-vehicle telematics units — anywhere Unisoc silicon was cost-competitive. If your job is to assess any of that hardware, “we scanned the exposed services and they looked fine” is not an answer anymore. It was never really an answer; the Unisoc chain just made it impossible to pretend otherwise.
The uncomfortable part: the skills required to find these bugs are learnable, but they are not the skills most pen testers were hired for. Nobody backed into baseband reverse engineering by fuzzing REST endpoints. Real IoT firmware analysis is a deliberate move, and it takes hands on hardware.
Go past the surface
If you’re a practitioner who’s read this far, you already suspect your current IoT engagements are leaving whole subsystems unaudited. You’re right. The IoT Hacking Deep Dive is built for exactly that person: a working pen tester who can run Burp and Nmap in their sleep but has never pulled a modem firmware off a live board, identified its RTOS, and mapped its IPC to the application kernel. The course walks through real chipset teardowns, firmware extraction on hardware you keep, RTOS fingerprinting, and the IPC-boundary auditing methodology that turns a story like Unisoc from a headline into a repeatable class of finding you can bring back to your engagements. If “go past surface scans” is where your practice needs to be next quarter, this is the direct path there.



