IoT Firmware Analysis: What the Switchvox Exploit Reveals About Embedded Attack Surface

iot firmware analysis — featured image

When attackers deployed reverse shells on Sangoma Switchvox servers without even logging in, they exposed a truth most IoT security programs ignore: the firmware you’re not analyzing is the firmware that will burn you. IoT firmware analysis isn’t an optional specialization on top of web-app pentesting — for embedded appliances, it’s the difference between finding a bug and understanding the blast radius.

Sangoma’s Switchvox SMB Edition 8.3 (build 104997) is affected by CVE-2026-9586, a critical unauthenticated SQL injection with a CVSS score of 9.3 that chains into remote code execution. Threat actors are already exploiting it in the wild to drop reverse shells. On paper, this is a boring web vulnerability class — SQLi in a login-adjacent endpoint. In practice, it’s a masterclass in why embedded appliances need a very different threat model than a SaaS web app running the same bug.

Because Switchvox isn’t a web app. It’s an embedded Linux appliance with a bootloader, a signed (or unsigned) update chain, a filesystem full of vendor binaries, and — usually — a UART header sitting on the board waiting to be found. The SQL injection is the front door. The interesting question is what a competent attacker does after walking through it, and what a defender or pentester who only reads the CVE writeup will completely miss. Serious IoT firmware analysis picks up exactly where that writeup ends.

The Switchvox Breach: When Traditional Web Vulns Meet Embedded Systems

The public reporting frames CVE-2026-9586 as an unauthenticated SQLi in Switchvox’s web admin interface. That framing is accurate but incomplete. The vulnerability is real; the framing hides where the real risk lives.

Every Switchvox appliance ships as a hardened Linux image on either dedicated hardware or a virtual appliance disk. The web management stack — PHP-based, running behind a fronting web server — is one of several long-lived services on that image. When the attacker’s SQL injection bootstraps into command execution as the web user, that user has read access to significant portions of the filesystem, network reachability to internal management interfaces, and — depending on how the appliance was hardened — a well-worn path to root through misconfigured sudoers, setuid binaries, or writable service scripts. That’s not a Switchvox-specific quirk. That’s the standard embedded-appliance failure mode, and it’s the same class of issue OWASP’s IoT Top 10 has been documenting for years.

Which means the CVE writeup describes the entry point. The actual attacker workflow after landing looks nothing like a typical web-app compromise. It looks like an embedded post-exploitation exercise. And the only way you know what’s reachable from that foothold — sensitive keys on disk, telephony databases full of DID mappings and voicemail, cross-appliance trust relationships, persistence primitives — is by having actually torn one of these boxes apart. That’s the work we teach in our free intro to IoT hacking: treat the appliance as a device, not a URL.

What Surface-Level IoT Pen Testing Misses — and Why IoT Firmware Analysis Fills the Gap

Most IoT engagements stop at the network edge. The tester runs Nmap, finds the web admin, throws Burp at it, files the report. If they’re feeling ambitious, they replay a known CVE and screenshot the shell. That’s the deliverable.

Everything interesting about the device is invisible to that workflow. Here’s what a firmware-first approach surfaces that a web-app-first approach never touches:

  • Bootloader trust and Secure Boot posture. Is U-Boot locked down? Are console commands password-gated? Can you drop to a prompt over UART and load an arbitrary kernel? On a huge fraction of appliances shipping today, the answer is “no, no, and yes.”
  • Update signature verification. Does the appliance verify update packages cryptographically, or does it just check a SHA256 against a manifest it also downloads? The difference between those two is the difference between “supply-chain-hardened” and “one MITM away from a persistent implant.”
  • Filesystem persistence primitives. Where can an attacker write that survives a firmware update? Which init scripts are consulted on every boot? Which “factory reset” paths actually reset, versus leaving attacker-planted files intact?
  • Credential and key material at rest. Hardcoded API tokens, service account keys, TLS private keys shared across every unit shipped, SIP trunk credentials that unlock the customer’s carrier account.
  • Inter-appliance trust. Many VoIP deployments cluster multiple Switchvox nodes. One compromised node with a shared cluster secret gets you the whole fleet.

None of that shows up in the Nessus scan. None of it shows up in the Burp report. It only shows up when you pull the image, extract the filesystem, and read it — which is exactly the IoT firmware analysis workflow we’ve written about before in our deep dive on IoT firmware kernel lock-in.

From SQL Injection to Persistent Implant: The IoT Firmware Analysis Checklist

Assume you have a Switchvox appliance in front of you, and CVE-2026-9586 gives you a shell as the web user. A surface-level tester writes the finding and moves on. A firmware analyst opens the checklist.

1. Get the firmware off the box

Two paths. If you have the vendor’s OVA or ISO, you already have the disk image — mount it, and you’re done. If you only have physical hardware, you locate the UART header (there is almost always a UART header), connect at 115200 8N1, and either dump flash from the U-Boot prompt or pull the disk directly. Then you run binwalk -Me firmware.bin to carve out squashfs, ext, cpio, and any embedded payloads. This is the same recon workflow that produced the analysis in our Cisco SD-WAN CVE-2024-5 firmware breakdown — different vendor, same methodology.

2. Map the root filesystem

Once the filesystem is extracted, you catalog services: what’s in /etc/init.d/, what runs from systemd units, what cron does. You grep for the SQLi entry point in the web stack and trace it to what it can reach — which config files it reads, which shell commands it invokes, which database it queries. That trace tells you what the reverse-shell payload actually has on the other side of the door.

3. Reverse the interesting binaries

Load the vendor-proprietary daemons into Ghidra. Look for the update client — that’s usually where signature verification either exists or embarrassingly doesn’t. Look for the licensing service — that’s where hardcoded keys live. Look for the clustering daemon — that’s where the shared secret is. This is the reverse-engineering core of any real IoT firmware analysis engagement.

4. Model the trust boundaries

Write down, explicitly: what does the appliance trust? The vendor’s update server? Any peer node on the management VLAN? The certificate authority baked into /etc/ssl/certs/? Every trust boundary is either a mitigation you can rely on or a lateral movement path an attacker will use.

5. Design the persistent implant scenario

This is where the exercise stops being academic. If you can drop a file into the filesystem that survives reboot, survives factory reset, and survives firmware update — you have described the real risk of CVE-2026-9586 to a customer. “Attacker gets a shell” is a bullet point. “Attacker plants an implant that persists across your next patch cycle and pivots into your PBX cluster” is a budget conversation.

How Lufsec’s Hands-On Teardown Approach Maps the Full Attack Surface

This is why we built the LufSec course catalog around real hardware and real firmware, not slideware. In the lab, you don’t watch someone else run binwalk — you extract the image yourself, you attach the USB-to-UART cable yourself, you drop to the bootloader yourself, and you decide what to look for next based on what you found. That’s what IoT firmware analysis looks like when it’s a working skill instead of a slide title.

The same reasoning applies at the network layer. Once you understand that a compromised VoIP appliance is a foothold into a customer’s internal network — and that adjacent embedded devices on that network almost certainly ship with worse security than the appliance you just rooted — the scope of the engagement grows honestly, not artificially. We wrote about this dynamic in the context of botnet compromise in our post on IoT security lessons from the C0xmo botnet: the compromised device is rarely the target. It’s the beachhead.

Switchvox is not going to be the last enterprise appliance that ships with a SQL injection in its admin interface. It won’t even be the last one this quarter. What changes across engagements is not the class of bug — it’s how much of the actual risk your methodology lets you see. If your workflow ends at “got shell,” you’re reporting 10% of the attack surface and calling it a pentest.

Go past the web-facing 10%

If you can already exploit IoT devices at the network layer and you’re wondering whether IoT firmware analysis is worth the investment, the honest answer is: it’s the difference between doing IoT pentesting and doing IoT security. Everything above the firmware is table stakes; everything meaningful about persistence, supply chain, and lateral movement is decided below it.

Our IoT Hacking Deep Dive is built for exactly this reader: the practitioner who can already land a shell on an embedded appliance and wants to know what to do with it. You’ll pull firmware off real hardware, extract and reverse vendor binaries in Ghidra, walk bootloader trust chains from UART, and build the kind of end-to-end attack narrative that turns a CVE reference into a customer-critical finding. If the Switchvox story reads to you as an entry point rather than a conclusion, this is the course that finishes the story.