Zero-Click Exploit Attack
In a recent interview session, we asked candidates about zero‑click exploits to evaluate whether they understand modern, advanced attack vectors that go beyond the typical ‘click a malicious link’ scenarios. Here is Sample Answer which help you to ace your next interview.(If miss our session how to crack Pentest interview you must Read This)
For Detail Anlysis you can refer this report
Definition
A zero‑click exploit attack is a cyberattack that compromises a device or application without requiring the victim to click, tap, or interact with anything. These attacks exploit hidden software vulnerabilities, making them extremely dangerous because they can silently steal data or install spyware without the user’s knowledge — by Kaspersky
What Is a Zero‑Click Exploit?
- Definition: A zero‑click exploit (or zero‑click attack) is a vulnerability that can be triggered remotely without any user interaction.
- Mechanism: Attackers craft malicious data packets, messages, or files that exploit flaws in software (e.g., messaging apps, email clients, or AI agents).
- Impact: Once triggered, the exploit can allow:
a. Data exfiltration (personal, financial, or medical records).
b. Spyware installation (e.g., Pegasus spyware).
c. Remote code execution (full control of the device).
Pegasus / FORCEDENTRY Zero-Click Exploit
1. How to Structure Your Interview Answer
The golden rule: match technical depth to the question tier. Lead with the one-liner, go deeper only when asked. Interviewers at all levels reward clarity over volume. Here is the layered structure that works at every seniority level:
Layer 1 — One-liner (always lead with this, regardless of level)
“FORCEDENTRY is a zero-click iMessage exploit — CVE-2021–30860 — that installs Pegasus spyware with no user interaction, by triggering an integer overflow in Apple’s JBIG2 image parser inside the CoreGraphics framework, bypassing Apple’s BlastDoor sandbox entirely.”
Layer 2 — Attack chain (mid-level)
Delivery (.gif-named JBIG2/PDF file via iMessage) → auto-parse outside BlastDoor in IMTranscoderAgent → integer overflow (numSyms wraparound) → heap buffer overflow → Turing-complete JBIG2 virtual CPU bootstraps RCE (bypasses PAC/CFI) → NSPredicate logic bug escapes sandbox via CommCenter IPC → kernel exploit escalates to root → Pegasus silently installed.
Layer 3 — Why it matters (senior level)
Three things make FORCEDENTRY extraordinary:
- It went AROUND BlastDoor — not through it — exploiting a media processing pathway Apple never sandboxed for this input.
- NSO built a Turing-complete virtual 64-bit computer inside a JBIG2 image stream — making PAC, ASLR, and CFI completely irrelevant, since no native code pointer is ever executed.
- The sandbox escape used only logic bugs (NSPredicate/NSFunctionExpression), which are immune to all hardware mitigations. This combination is what Google Project Zero called “one of the most technically sophisticated exploits ever seen.”
Layer 4 — Defender perspective (differentiator at any level)
The fix for CVE-2021–30860 was just two bounds checks before the buffer allocation in readTextRegionSeg. The structural fix is Apple’s Lockdown Mode — default-deny on complex media codec exposure to untrusted input. The sandbox escape required zero-trust IPC: CommCenter should not evaluate NSPredicates originating from a sandboxed process. Forensically, Pegasus leaves CASCADEFAIL — orphaned ZLIVEUSAGE rows in DataUsage.sqlite — detectable with a single SQLite query and the open-source MVT tool.
2. Exploit Chain — Step-by-Step Reference Diagram
Use this chain as your mental model when answering. Each stage maps to a specific technique category — quote the stage names and technical labels during your answer.
ZERO INTERACTION-The entire 9-stage chain fires automatically on message receipt. The victim is never asked to click, open, swipe, or approve anything. This is what ‘zero-click’ means.
3. Interview Q&A — Questions with Answers
Tier 1 — Junior / Graduate (fundamentals, every interview)
Q1. What is a zero-click exploit and how does it differ from a one-click attack?
Answer: A one-click attack requires the victim to take an action — click a link, open a file, answer a call — before the payload fires. A zero-click exploit fires automatically when data is received and processed by the device, with no interaction from the victim whatsoever. The attack surface is any code that executes automatically on incoming data — iMessage parsers, email renderers, SMS preview handlers. FORCEDENTRY is a zero-click: the iPhone is fully compromised the moment the malicious iMessage is received and processed in the background, before the user sees any notification.
Key terms: zero interaction | automatic processing | IMTranscoderAgent | attack surface = auto-parsers
Q2 .Walk me through the FORCEDENTRY exploit at a high level.
Answer: The attacker sends a .gif-named file — actually a PDF containing JBIG2 image streams — to the victim’s iMessage. iOS auto-routes it through CoreGraphics in the IMTranscoderAgent process, which runs outside Apple’s BlastDoor sandbox. This triggers CVE-2021–30860 — an integer overflow in the JBIG2 parser that causes a massive heap buffer overflow. NSO Group then uses 70,000+ JBIG2 segment commands to build a Turing-complete virtual CPU inside the decompression pass, bootstrapping arbitrary code execution without touching native code pointers. A NSPredicate logic bug then escapes the sandbox via CommCenter IPC. A kernel exploit escalates to root. Pegasus is silently installed. Zero user interaction at any stage.
Key terms: CVE-2021–30860 | JBIG2 integer overflow | BlastDoor bypass | NSPredicate sandbox escape | zero interaction
Tier 2 — Mid-level (exploitation mechanics, memory bugs, sandbox)
Q1.Explain the integer overflow in CVE-2021–30860. What exactly overflows and what is the consequence?
Answer: Inside JBIG2Stream::readTextRegionSeg in CoreGraphics, numSyms is calculated by summing the size fields of multiple JBIG2 SymbolDict segments. Both values are unsigned 32-bit integers. Two large values — e.g. 0x80000000 + 0x80000001 — wrap around to 1 due to uint32 overflow. A heap buffer called syms is then allocated as numSyms * sizeof(pointer) — just 8 bytes instead of gigabytes. The fill loop that populates syms still uses the original large segment counts, not the overflowed result — so it writes vastly more data than the buffer can hold. This is a classic CWE-190 integer overflow leading to a CWE-122 heap buffer overflow, giving the attacker out-of-bounds write primitives and control over adjacent heap objects.
Key terms: uint32 wraparound | CWE-190 / CWE-122 | heap OOB write | readTextRegionSeg | numSyms
Q2.How did FORCEDENTRY bypass Apple’s BlastDoor sandbox?
Answer: BlastDoor was introduced in iOS 14 specifically to prevent zero-click iMessage attacks. It sandboxes parsing of iMessage data — JSON, text, links — in an isolated process. FORCEDENTRY did not break BlastDoor; it found a pathway never covered by it. By naming the exploit payload with a .gif extension, the attacker caused iMessage to route the file through IMTranscoderAgent and CoreGraphics for media transcoding — a pathway that runs entirely outside the BlastDoor sandbox. The JBIG2 vulnerability was in CoreGraphics, which Apple had not yet sandboxed for this class of input. This is a textbook example of an incomplete trust boundary — the defense covered only part of the attack surface.
Key terms: BlastDoor not in path | IMTranscoderAgent external | .gif routing trick | incomplete trust boundary | CoreGraphics
Q3.Why did NSO Group build a virtual CPU in JBIG2 instead of using ROP/JOP chains?
Get appsecwarrior’s stories in your inbox
Join Medium for free to get updates from this writer.
Answer: ROP and JOP chains manipulate function pointers and return addresses to chain existing code gadgets. Apple’s PAC (Pointer Authentication Codes) defends against exactly this — it cryptographically signs all function pointers, and using an unsigned or forged pointer causes an authentication fault. By constructing a Turing-complete virtual machine using JBIG2’s built-in logical bitmap operations (AND, OR, XOR, XNOR on pixel regions), NSO ran their bootstrapping code entirely inside the image decompression pass with no native code execution at all. PAC, ASLR, and CFI have zero effect on JBIG2 logical operations — they are pixel manipulations, not code pointers. The VM had 64-bit registers, arithmetic, memory read/write, and conditional branching — enough to perform the full heap manipulation and fake object construction needed for stage 6.
Key terms: PAC defeated | Turing-complete JBIG2 | no native code exec | NAND-complete logic | bitmap ops
Tier 3 — Senior / Principal (novel techniques, mitigations, forensics)
Q1.Explain how the sandbox escape worked and why it bypassed all hardware mitigations.
Answer: After achieving RCE inside IMTranscoderAgent, NSO used a pure logic bug — not memory corruption — for the sandbox escape. They abused NSPredicate, Apple’s Objective-C object graph querying engine. With the FUNCTION keyword, NSPredicates can call arbitrary Objective-C methods, making them an effective scripting engine. A malicious NSPredicate was serialised as an NSKeyedArchiver blob and routed to the CommCenter process via the com.apple.commcenter IPC channel, which is accessible from the IMTranscoderAgent sandbox. CommCenter runs at higher privileges, so arbitrary Obj-C method calls inside CommCenter’s context gave them a foothold outside the sandbox. The key point: hardware mitigations defend against memory corruption. A logic bug exploits legitimate system APIs with valid, properly signed code — PAC has nothing to authenticate against. This is why logic bugs are more dangerous than memory corruption bugs in hardened environments.
Key terms: logic bug — no memory corruption | NSPredicate / NSFunctionExpression | CommCenter IPC | PAC irrelevant to logic bugs | NSKeyedArchiver
Q2.What is CASCADEFAIL and how would you use it in a forensic investigation?
Answer: CASCADEFAIL is a forensic artefact left by Pegasus’s self-cleanup routine. When finishing a surveillance mission, Pegasus deletes its entries from the ZPROCESS table in iOS’s DataUsage.sqlite — the database tracking per-app network usage. However it fails to delete corresponding ZLIVEUSAGE rows that reference those ZPROCESS entries via a foreign key (ZHASPROCESS). These orphaned rows — pointing to non-existent ZPROCESS records — are the CASCADEFAIL signature. In a forensic investigation: extract DataUsage.sqlite from an iTunes backup or direct device image, then run: SELECT ‘CASCADEFAIL’ FROM ZLIVEUSAGE WHERE ZLIVEUSAGE.ZHASPROCESS NOT IN (SELECT Z_PK FROM ZPROCESS). Any result confirms Pegasus deleted its ZPROCESS entries but left orphaned ZLIVEUSAGE rows. Amnesty’s MVT tool automates this check. This artefact has been consistent across all documented Pegasus infections and survives even after the malware self-destructs.
Key terms: orphaned ZLIVEUSAGE rows | DataUsage.sqlite | SQLite forensics | MVT open-source | CASCADEFAIL
Q3.As a defender, what would you implement to detect or prevent this class of attack?
Answer: Prevention: Reduce attack surface — Apple’s Lockdown Mode is the model: restrict which codecs process untrusted iMessage attachments, disable complex media processing. Apply memory-safe language rewrites to legacy parsers like JBIG2 and TIFF — eliminating integer overflow bugs entirely. Validate input bounds before allocation: the CVE-2021–30860 fix was two overflow checks before the syms buffer allocation. Architecture: enforce zero-trust on IPC channels — CommCenter should never evaluate NSPredicates from a sandboxed process. Treat all IPC as a trust boundary. Detection: Monitor for repeated IMTranscoderAgent crashes, abnormal process spawning from messaging daemons, and unexpected CommCenter IPC traffic. Run MVT quarterly on high-risk devices to check for CASCADEFAIL and known Pegasus C2 domains. Deploy behavioural EDR on mobile endpoints — process-level analysis, not signature AV. Enable Apple Threat Notifications and act immediately on any alert.
Key terms: Lockdown Mode | memory-safe rewrites | zero-trust IPC | bounds checks | MVT / iVerify | Threat Notifications
Q4.Map this attack to pentest methodology and vulnerability classification frameworks.
Answer: FORCEDENTRY is a complete kill chain. Initial access: zero-click delivery via iMessage (no phishing required). Execution: CVE-2021–30860 memory corruption — CWE-190 integer overflow leading to CWE-122 heap buffer overflow. Defence evasion: Turing-complete JBIG2 VM bypasses PAC/CFI; sandbox escape via logic bug bypasses all hardware mitigations; self-cleanup attempts to remove forensic evidence (partial, leaves CASCADEFAIL). Privilege escalation: kernel exploit chains from CommCenter to root. Collection and exfiltration: Pegasus C2 infrastructure. MITRE ATT&CK Mobile: T1203 (exploit for client execution), T1404 (exploit OS vulnerability), T1631 (process injection / IPC abuse), T1630 (indicator removal). CWEs: CWE-190 (integer overflow), CWE-122 (heap buffer overflow), CWE-269 (improper privilege management), CWE-693 (incomplete sandbox boundary). From a red team debrief perspective: the virtual CPU and the logic-bug-only sandbox escape are both advanced tradecraft worth highlighting as novel TTPs.
Key terms: CWE-190 / CWE-122 | T1203 / T1404 / T1631 / T1630 | kill chain | heap grooming | zero-trust IPC | tradecraft
4. Key Concepts Map — What to Say at Each Depth
This table maps the concepts you should introduce at each seniority tier. The deeper the interview, the more of these terms you weave in naturally.
5. MITRE ATT&CK & CWE Mapping
5.1 MITRE ATT&CK for Mobile
5.2 CWE Vulnerability Classification
6. Key Technical Terms — Quick Reference Glossary
Drop these terms naturally during your interview answer. Each entry is one sentence.
7. One-Page Cheat Sheet — Everything in 60 Seconds
The one-liner (memorise this)
FORCEDENTRY is a zero-click iMessage exploit (CVE-2021–30860) that installs Pegasus spyware by triggering a JBIG2 integer overflow in CoreGraphics, bypassing Apple’s BlastDoor sandbox, then using a Turing-complete virtual CPU inside the image stream to avoid PAC/CFI, and escaping the process sandbox via a NSPredicate logic bug over CommCenter IPC.
9 stages in 1 Line each
1.Delivery — .gif-named JBIG2 PDF sent via iMessage
2.Auto-parse — IMTranscoderAgent processes outside BlastDoor
3.Bypass — BlastDoor never in CoreGraphics media path
4.Overflow — uint32 numSyms wraps; syms heap too small
5.Virtual CPU — 70k JBIG2 ops = Turing-complete 64-bit VM
6.RCE — Fake vtable + NSFunctionExpression in IMTranscoderAgent
7.Escape — NSPredicate logic bug → CommCenter IPC privilege
8.PrivEsc — Kernel vuln → root; ASLR slide = 0
9.Payload — Pegasus installed; CASCADEFAIL in DataUsage.sqlite
MITRE quick cite -T1203 (exploit execution) → T1404 (OS priv-esc) → T1631 (IPC injection) → T1630 (indicator removal) | CWE-190 + CWE-122 + CWE-269 + CWE-502 + CWE-668
Reference Sources
✍️https://googleprojectzero.blogspot.com/2021/12/a-deep-dive-into-nso-zero-click.html







