CVE-2024-27834: Apple WebKit JavaScriptCore JIT Pointer Authentication (PAC) Bypass (Pwn2Own / CISA KEV)
On November 4, 2026, the Cybersecurity and Infrastructure Security Agency (CISA) added CVE-2024-27834 to its Known Exploited Vulnerabilities (KEV) catalog following verified telemetry of targeted in-the-wild zero-day weaponization against Apple macOS and iOS endpoints. The vulnerability was weaponized as part of a zero-click exploit chain attributed to Russian foreign intelligence threat group APT29 (Midnight Blizzard / Nobelium) to deploy infostealer malware payloads. Originally discovered by security researcher Manfred Paul at Pwn2Own Vancouver 2024, the vulnerability breaks the core hardware defense mechanism of Apple Silicon ARM64e architectures: Pointer Authentication (PAC). By exploiting register-controlled tagging instructions within JavaScriptCore Just-In-Time (JIT) compiler thunks, an adversary possessing an initial memory corruption primitive in Safari or WebKit can turn the engine into a cryptographic signing oracle. This allows attackers to forge valid cryptographic pointer signatures, completely defeating hardware Control-Flow Integrity (CFI), achieving arbitrary native machine code execution, and executing full sandbox breakout chains without triggering hardware crash traps. Hermes evaluates this vulnerability at HTS 94 (CRITICAL).
HERMES THREAT SCORE & HARDWARE POINTER AUTHENTICATION DEFENSE EVALUATION
Target:Apple WebKit JavaScriptCore JIT Compiler (ThunkGenerators.cpp) [object Object]
1. Vulnerability Overview & Architectural Context
Section titled โ1. Vulnerability Overview & Architectural ContextโPointer Authentication (PAC) is a hardware-backed security extension introduced in ARMv8.3-A and standard across all Apple Silicon processors (A12 Bionic through A18, and M1 through M4). In modern Apple operating systems (macOS, iOS, iPadOS, watchOS, and tvOS), PAC acts as the ultimate line of defense against memory corruption exploitation. By computing a cryptographic message authentication code (MAC) over a 64-bit pointer and a 64-bit modifier/context using dedicated hardware keys (IA, IB, DA, DB), PAC embeds the signature into the unused high-order bits of the pointer. Before dereferencing or jumping to the pointer, CPU instructions like autia or autib verify the signature. If a single bit has been altered, the instruction translates the pointer into an invalid address, triggering a kernel trap (EXC_BAD_ACCESS) and terminating the process before attacker payload execution.
+-------------------------------------------------------------------+ | 64-bit ARM64e Pointer Architecture | +-------------------------------------------------------------------+ | 63 55 | 54 0 | | [ 8-bit PAC Tag ] | [ 47-bit Virtual Address ] | +-------------------+-----------------------------------------------+ | +--> Cryptographic Signature = HMAC-SHA(Address, Key, Context)In high-performance browser runtimes like Appleโs WebKit, the JavaScriptCore (JSC) engine uses Just-In-Time (JIT) compilation to compile dynamic JavaScript and WebAssembly into native ARM64e machine instructions. Because JIT engines dynamically generate executable code pages, they have historically represented the primary attack vector for browser compromise. To prevent attackers who gain arbitrary read and write capabilities in the WebKit renderer from redirecting execution flow, Apple hardened JavaScriptCore by requiring all internal function pointers, dispatch tables, and embedding stubs to be strictly PAC-signed using the IB (Instruction B) key.
CVE-2024-27834 fundamentally breaks this security paradigm. Disclosed by researcher Manfred Paul at Pwn2Own Vancouver 2024 and confirmed by CISA KEV as actively exploited in targeted surveillance and zero-day intrusion campaigns, the vulnerability allows an attacker who has achieved memory corruption inside the Safari renderer process to turn JavaScriptCoreโs own JIT compiler thunks into a PAC signing oracle. By passing controlled registers into an unsafe JIT thunk helper, an attacker can generate mathematically valid PAC signatures for arbitrary pointers, transforming a limited sandbox memory corruption flaw into full arbitrary native code execution.
2. Root Cause Analysis & Code Breakdown
Section titled โ2. Root Cause Analysis & Code BreakdownโThe vulnerability resides within JavaScriptCoreโs JIT compilation thunks in Source/JavaScriptCore/jit/ThunkGenerators.cpp. During JIT code generation, the engine creates small reusable machine code sequences called โthunksโ to facilitate context transitions, such as transitioning between WebAssembly runtime execution and native C++ host embedders (wasmToEmbedderStub).
// Source/JavaScriptCore/jit/ThunkGenerators.cpp (Vulnerable Code Flow)MacroAssemblerCodeRef<JITThunkPtrTag> wasmToEmbedderThunkGenerator(VM& vm){ CCallHelpers jit;
// Setup argument registers and stack frame jit.emitFunctionPrologue();
// Attacker-accessible thunk generation sequence: // When preparing the stub pointer, the code invokes tagPtr with a register argument: jit.tagPtr(tagRegister, destinationRegister); jit.pacib(destinationRegister, tagRegister);
jit.ret(); return JSInterfaceJIT::linkChildren(jit, vm, "wasmToEmbedder");}The Architectural Flaw: The Signing Oracle Primitive
Section titled โThe Architectural Flaw: The Signing Oracle PrimitiveโIn ARM64e Pointer Authentication, pointer signing instructions require two inputs:
- The pointer value (stored in a target 64-bit general-purpose register, e.g.,
x16orx17). - The context modifier/salt (either a 64-bit register value or an immediate zero value via
pacizb).
The security of PAC relies on strict context isolation: a pointer signed with a specific context (such as the address of the pointer itself or a fixed structural salt) cannot be authenticated and executed in a different context.
In ThunkGenerators.cpp, the implementation of helper thunks improperly allowed the signing modifier to be derived from a caller-controlled or register-influenced value without bounding the tag space. When an attacker with an initial JavaScriptCore heap corruption (e.g., an array out-of-bounds read/write or type confusion) inspects the JIT code cache, they locate this JIT thunk in memory. Because the thunk executes legitimate pacib instructions on registers that can be populated through controlled JavaScript or WebAssembly function calls, the attacker can invoke the thunk with:
destinationRegisterset to the address of their shellcode or ROP gadget chain.tagRegisterset to the exact modifier required by a high-value function pointer target (such as a Virtual Method Table pointer orwasmToEmbedderStub).
The hardware executes the JIT thunk, signs the attackerโs arbitrary address with Appleโs private in-kernel IB key, and writes the newly minted PAC-signed pointer back to a register or stack slot. The attacker then copies this forged pointer into the targeted execution table.
Appleโs Remediation Patch
Section titled โAppleโs Remediation PatchโIn macOS Sonoma 14.5 and iOS 17.5, Apple eliminated the register-based tagging gadget in ThunkGenerators.cpp. The vulnerable tagPtr invocation was replaced with pacizb using a hardcoded NoPtrTag (zero context) and invariant structural modifiers that cannot be influenced by caller registers:
// Patched Source/JavaScriptCore/jit/ThunkGenerators.cppMacroAssemblerCodeRef<JITThunkPtrTag> wasmToEmbedderThunkGenerator(VM& vm){ CCallHelpers jit; jit.emitFunctionPrologue();
// HARDENED: Remove register-controlled tag manipulation. // Use fixed architectural tag invariants (pacizb with NoPtrTag context): jit.pacizb(destinationRegister);
jit.emitFunctionEpilogue(); jit.ret(); return JSInterfaceJIT::linkChildren(jit, vm, "wasmToEmbedder");}By removing register-directed pointer tagging, the JIT thunk can no longer be coerced into signing arbitrary addresses with attacker-supplied salt modifiers, neutralizing the signing oracle gadget.
3. Attack Vector & Exploitation Flow
Section titled โ3. Attack Vector & Exploitation FlowโIn real-world zero-day attack campaigns cataloged by CISA KEV, CVE-2024-27834 is deployed as Stage 2 of a multi-stage mobile or desktop exploit chain:
+-----------------------------------------------------------------------------------+| Multi-Stage Exploit Chain |+-----------------------------------------------------------------------------------+| Stage 1: Initial Browser Compromise || - Malicious web page delivered via iMessage, SMS (smishing), or watering-hole. || - JIT type confusion or OOB write in WebKit creates arbitrary memory read/write. |+-----------------------------------------------------------------------------------+ | v+-----------------------------------------------------------------------------------+| Stage 2: Hardware PAC Bypass (CVE-2024-27834) || - Attacker locates JIT Thunk in executable memory. || - Calls thunk as a signing oracle with target shellcode address and tag context. || - Receives cryptographically valid ARM64e PAC signature. || - Overwrites wasmToEmbedderStub; control flow hijacked without CPU panic. |+-----------------------------------------------------------------------------------+ | v+-----------------------------------------------------------------------------------+| Stage 3: Sandbox Breakout & Kernel Elevation || - Renderer process now runs native shellcode under com.apple.WebKit.WebContent. || - Leverages XPC Mach message vulnerabilities (e.g. CVE-2026-65381) to escape || the App Sandbox and compromise launchd / root kernel context. |+-----------------------------------------------------------------------------------+Exploit Execution Steps
Section titled โExploit Execution Stepsโ-
Initial Memory Corruption Primitives: The attacker lures an Apple device user to a weaponized URL. A preliminary WebKit bug (such as integer truncation in the JIT compiler) allows the creation of fake
JSArrayobjects, giving the attacker arbitrary 64-bit memory read and write primitives within thecom.apple.WebKit.WebContentaddress space. -
Locating the JIT Thunk Oracle: On ARM64e systems, directly overwriting function pointers results in an instant process crash upon execution due to PAC verification failure. The attacker traverses the JIT code allocation pool, parsing Mach-O headers and JIT thunk tables to pinpoint the offset of the vulnerable
wasmToEmbedderThunkGeneratorentry point. -
Cryptographic Signature Forgery: The attacker passes the address of their shellcode buffer (located in a writable/executable JIT page or mapped dylib) along with the expected PAC salt to the thunk. The CPU executes
pacib, outputting a pointer with a valid cryptographic tag in bits[63:56]. -
Control Flow Hijacking: The attacker writes the signed pointer into the target function table. When JavaScript code triggers the WebAssembly embedding call, the CPU verifies the forged PAC signature with
autib, passes authentication cleanly, and jumps directly to the attackerโs payload. -
Sandbox Breakout via Mach IPC: Operating with native machine execution within the WebContent sandbox, the payload interacts with privileged system daemons via Mach ports (
mach_msg()) and XPC endpoints to exploit local privilege escalation vulnerabilities and implant persistent surveillance malware.
4. Forensic Investigation & Threat Hunting
Section titled โ4. Forensic Investigation & Threat HuntingโBecause CVE-2024-27834 manipulates JIT compiler execution paths to bypass hardware controls, detection relies on endpoint telemetry, crash dump analysis, and child process monitoring on macOS and iOS.
Sigma Detection Rule: Unauthorized WebKit Child Process Execution
Section titled โSigma Detection Rule: Unauthorized WebKit Child Process ExecutionโUnder normal operation, the com.apple.WebKit.WebContent process never spawns shell interpreters, administrative utilities, or Mach-O compilation binaries.
title: Suspicious Child Process Spawned by Apple WebKit WebContentid: 5a8e2b9c-4f71-419b-89d2-cve202427834-sigmastatus: productiondescription: Detects unexpected child processes spawned by Apple Safari WebKit WebContent renderer, indicating successful PAC bypass and native shellcode execution.author: Hermes Codex Cyber Risk Intelligencedate: 2026-11-05references: - https://www.cisa.gov/known-exploited-vulnerabilities-catalog?search_api_fulltext=CVE-2024-27834 - https://support.apple.com/en-us/HT214106logsource: category: process_creation product: macosdetection: selection: ParentImage|endswith: - '/com.apple.WebKit.WebContent' - '/Safari.app/Contents/MacOS/Safari' Image|endswith: - '/sh' - '/bash' - '/zsh' - '/curl' - '/osascript' - '/python3' - '/launchctl' - '/plutil' condition: selectionfields: - ProcessId - Image - CommandLine - ParentProcessId - ParentImagefalsepositives: - Custom browser automation suites or developer test harnesses in debugging modelevel: criticaltags: - attack.execution - attack.t1203 - attack.t1068 - cve.2024.27834Detection Engineering & Forensic Triage Tabs
Section titled โDetection Engineering & Forensic Triage Tabsโ// Detect anomalous child process execution from WebKit WebContent on macOSDeviceProcessEvents| where Timestamp > ago(14d)| where InitiatingProcessFileName =~ "com.apple.WebKit.WebContent"| where FileName in~ ("sh", "zsh", "bash", "curl", "python3", "osascript", "launchctl", "whoami", "uname")| project Timestamp, DeviceName, DeviceId, InitiatingProcessFileName, InitiatingProcessCommandLine, FileName, ProcessCommandLine, AccountName| order by Timestamp desc# Query macOS Unified Logging for Pointer Authentication fault traps in WebContentlog show --predicate 'process == "com.apple.WebKit.WebContent" AND eventMessage CONTAINS[c] "PAC"' --info --debug --last 24h
# Check DiagnosticReports for WebContent crash logs with EXC_BAD_ACCESS (KERN_INVALID_ADDRESS)# where register values indicate pointer authentication failure:grep -rn "EXC_BAD_ACCESS (KERN_INVALID_ADDRESS)" /Library/Logs/DiagnosticReports/com.apple.WebKit.WebContent* 2>/dev/nullgrep -rn "Termination Reason:.*PAC" ~/Library/Logs/DiagnosticReports/ 2>/dev/nullCrashed Thread: 0 Dispatch queue: com.apple.main-threadException Type: EXC_BAD_ACCESS (SIGSEGV)Exception Codes: KERN_INVALID_ADDRESS at 0x00407fffffffc000Exception Note: EXC_CORPSE_NOTIFYTermination Signal: Segmentation fault: 11Termination Reason: Namespace SIGNAL, Code 11 Segmentation fault: 11Terminating Process: exc handler [com.apple.WebKit.WebContent]
Faulting Pointer Breakdown:Register x16: 0x00407fffffffc000 <-- Note bits 55-63 mangled by PAC hardware failureBacktrace:0 JavaScriptCore 0x19a4f2104 wasmToEmbedderThunkGenerator + 1241 JavaScriptCore 0x19a4e8720 JITThunks::hostThunk + 885. Remediation Strategy & Mitigation Guidance
Section titled โ5. Remediation Strategy & Mitigation GuidanceโTo protect enterprise macOS and iOS fleets against CVE-2024-27834 exploitation:
1. Vendor Patch Deployment
Section titled โ1. Vendor Patch DeploymentโApple addressed CVE-2024-27834 across its entire ecosystem in May 2024 releases. Ensure all managed devices meet or exceed the following firmware thresholds:
- macOS: Update to macOS Sonoma 14.5 or later (or macOS Ventura 13.6.7 / macOS Monterey 12.7.5 with Safari 17.5).
- iOS / iPadOS: Update to iOS 17.5 or iPadOS 17.5 (or iOS 16.7.8 for legacy devices).
- Safari: Ensure Safari is updated to version 17.5 across all platforms.
- Apple Watch & Apple TV: Update to watchOS 10.5 and tvOS 17.5.
2. Lockdown Mode Activation for High-Risk Personas
Section titled โ2. Lockdown Mode Activation for High-Risk PersonasโFor high-profile executives, security researchers, and personnel subject to targeted zero-day attacks, enable Apple Lockdown Mode:
- Lockdown Mode disables Just-In-Time (JIT) compilation entirely in Safari and WebKit.
- Without JIT compilation enabled, JavaScriptCore never generates executable memory pages or JIT thunks, mathematically eliminating the attack surface required for CVE-2024-27834 exploitation.
3. Enterprise MDM Enforcement
Section titled โ3. Enterprise MDM EnforcementโEnterprise administrators utilizing Jamf Pro, Microsoft Intune, or VMware Workspace ONE should enforce immediate compliance policies requiring OS versions at or above macOS 14.5 and iOS 17.5, restricting enterprise network access (802.1X, VPN gateways) for non-compliant endpoints.