Mobile Exploit Chains
Exploit Chains & Real-World Case Studies · Exploit Development track
7 min read
In this module
The Phone in Your Pocket
Smartphones are an awkward target. iOS and Android stack up application sandboxing, code signing, verified boot, hardware security enclaves, and a steady drumbeat of security updates. Getting a "full chain with persistence" — owning a modern phone in a way that survives reboot — means stringing together bugs across several of those layers.
The market puts a number on that difficulty. A zero-click full-chain against the latest iPhone has changed hands for several million dollars, and the price reflects both the labour involved and how badly intelligence services want one.
iOS Security Architecture
iOS layers its defences, and any chain has to push through every layer.
Application sandbox: each app runs in its own little world, with access to its own data and basically nothing else. Apps don't read each other's files, don't poke at arbitrary system resources, and have to ask the user before touching anything sensitive.
Code signing: only code signed by Apple (or by an Apple-issued developer cert, for App Store builds) gets to run. Unsigned binaries don't execute on a non-jailbroken iPhone, full stop. Attackers can't drop their own binary; they have to find a way to make an already-signed process run their code.
PAC (Pointer Authentication Codes): from the A12 onwards, function pointers and return addresses get cryptographically signed. Tamper with one and you don't have the key to re-sign it, so dereferencing it crashes. ROP gets a lot uglier under PAC.
PPL (Page Protection Layer): a hardware-backed split inside the kernel that guards page table modifications. Even with kernel code execution, you can't just flip writable memory to executable — a favourite post-exploitation move that PPL takes off the table.
Secure Enclave Processor (SEP): a separate processor with its own firmware, handling biometrics (Face ID, Touch ID), encryption keys, and other secrets. Owning the main kernel buys you nothing inside the SEP.
Here's the order a zero-click chain meets those layers, with the stage that deals with each. The first two boxes name what FORCEDENTRY (covered below) did; the kernel, PAC and PPL boxes show the general options from steps 3 and 4 of the chain, since the public write-ups of FORCEDENTRY don't cover those stages:
The iOS Exploit Chain
Full iOS chains tend to follow a familiar shape.
1. Initial vulnerability: a bug in code that handles untrusted input. For zero-click attacks, that means something processed automatically:
- iMessage (IMTranscoderAgent, ImageIO, CoreGraphics)
- FaceTime/VoIP call handling
- Wi-Fi/Bluetooth stack
- SMS/MMS processing
For one-click attacks (the user has to tap a link), the target is usually Safari's WebKit engine.
2. Sandbox escape: the foothold process is sandboxed, so the attacker has to climb to something more privileged. Common routes:
- an IPC bug in a privileged system service
- a kernel bug reachable through one of the syscalls the sandbox still permits
- a bug in a daemon the sandboxed process is allowed to talk to
3. Kernel exploitation: full device control needs a kernel bug. Kernel read/write gives the attacker the keys: disable code signing enforcement, rewrite process credentials to get root, read any file on the device, lay the groundwork for a persistent implant.
4. PAC bypass: on modern iPhones, you'll need to defeat Pointer Authentication. Options include:
- finding a PAC signing oracle — some kernel function willing to sign pointers it shouldn't
- exploiting a context where the relevant pointers aren't PAC-protected to begin with
- skipping pointers entirely and doing data-only attacks that mangle non-pointer fields to reach the same goal
5. Persistence: surviving reboot is the hardest part. iOS's verified boot chain inspects every component from bootloader to kernel. Persistence usually means one of:
- modifying the filesystem in a way the integrity checks miss
- exploiting a bug somewhere in the boot chain
- giving up on on-disk persistence and re-exploiting on every boot (e.g. via iMessage)
A zero-click exploit owns a device without the victim doing anything. The trigger is whatever the phone handles automatically — an incoming message, a missed call, a notification. The user never taps a link, never opens a file, never gets a chance to make a mistake. That's also why these are the most expensive and hardest to develop: they take the user's judgement out of the equation entirely.
The FORCEDENTRY Chain
FORCEDENTRY is the best-documented iOS chain in public. Used by NSO Group's Pegasus spyware, taken apart by Google's Project Zero and Citizen Lab in 2021.
Stage 1 — iMessage processing: the attackers sent a crafted PDF dressed up as a GIF. iMessage's IMTranscoderAgent processed the attachment automatically. Inside the PDF was a JBIG2 stream (a compression format) carrying a bug in CoreGraphics' JBIG2 decoder.
Stage 2 — Turing-complete computation: this is the part that made researchers' jaws drop. The attackers used the JBIG2 decoder's bitmap logical operations — AND, OR, XOR — to build a tiny virtual CPU inside the decoder. That virtual CPU then ran a program that computed the next stage of the exploit, all without ever executing native machine code. Traditional shellcode detection had nothing to look at.
Stage 3 — Sandbox escape: Project Zero's follow-up write-up (March 2022) showed the virtual CPU's program breaking out of IMTranscoderAgent's sandbox using only logic bugs, no memory corruption. Whatever kernel exploit came after that hasn't been publicly analysed, so how the chain got full device access is unknown outside Apple and the attackers.
Stage 4 — Payload deployment: with the kernel owned, Pegasus settled in as a persistent surveillance implant — reading messages, recording calls, switching on the camera and microphone, tracking location.
FORCEDENTRY mattered because it was fully zero-click, worked against the then-current iOS, and used a technique (the JBIG2 virtual computer) that nobody had publicly documented before.
Android Exploit Chains
Android is a different beast. Fragmentation — many manufacturers, many kernel forks, wildly varying patch levels — cuts both ways. There's a long tail of unpatched devices, but exploits don't always port between them.
Android's defences include:
- SELinux in enforcing mode, throttling what each process can do
- Verified Boot that checks system partition integrity
- Application sandbox built on Linux user IDs and namespaces
- Seccomp filters on Chrome and the system WebView renderer
- Hardware-backed keystore for crypto operations
A typical Android chain looks like:
- Chrome/WebView vulnerability: a JS engine or renderer bug
- Chrome sandbox escape: IPC bug or kernel bug reachable from inside the sandbox
- Kernel exploit: often a device-specific driver — GPU, camera, vendor-specific interfaces — because those are audited less rigorously than core kernel
- SELinux bypass: rewriting policy or exploiting a permissive domain
- Root and persistence: get root, then modify enough of the system that it sticks across reboots
Fragmentation means kernel bugs are usually device-specific. A Qualcomm GPU driver vuln owns Qualcomm phones and only Qualcomm phones — Samsung Exynos and Google Tensor are unaffected. Each chain has a narrower target list than its iOS equivalent.
The Defence Response
Mobile platform vendors have spent serious money pushing chain costs up:
Bug bounty programs: Apple's top award for a zero-click remote chain rose to $2 million in late 2025, with bonuses (for example, for bypassing Lockdown Mode) that can take a single report past that. Google's Android and Chrome programmes publish their own, different tables. These figures change every year or two, so check the vendor's current page rather than trusting a number in a lesson. The aim is simple — make it more lucrative for researchers to report than to sell on the offensive market.
BlastDoor (iOS): a tightly sandboxed service that does the initial processing of incoming iMessage data. Written in Swift (memory-safe), parked in a minimal sandbox, and built to cut the attack surface a message can reach before IMTranscoderAgent ever sees it.
Memory Tagging Extension (Android): ARM's MTE tags each memory allocation with a random 4-bit tag. A pointer with the wrong tag faults on dereference. That's a probabilistic catch on use-after-free and buffer overflow, and it breaks a lot of standard exploitation primitives.
Lockdown Mode (iOS): a user-toggleable mode that switches off the more dangerous features at the price of some functionality. Messages blocks most attachment types apart from certain images, video and audio, and Safari turns off some complex web technologies. Apple doesn't say which decoders that rules out, but cutting the attachment formats a message can deliver shrinks exactly the kind of surface FORCEDENTRY went through. It exists because of mercenary spyware like Pegasus.
Every layer added forces attackers back to the drawing board, hunting new bugs and new techniques. Costs go up, the buyer pool shrinks.