Skip to content

CVE-2024-27834: Apple WebKit JavaScriptCore JIT Pointer Authentication (PAC) Bypass (Pwn2Own / CISA KEV)

Density:
C-Level Executive Briefing CVE-2024-27834 CRITICAL SCORE 94/100

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).

HYBRID

HERMES THREAT SCORE & HARDWARE POINTER AUTHENTICATION DEFENSE EVALUATION

Target: Apple WebKit JavaScriptCore JIT Compiler (ThunkGenerators.cpp)
Confidence: 99%
94 / 100
CRITICAL

Measures real-world operational relevance, exploit weaponization, and active threat posture.

Dimension Breakdown
Exploitability 19 / 20
Threat Activity 20 / 20
Weaponization 20 / 20
Exposure 18 / 20
Prevalence 19 / 20
Impact 20 / 20
Exploit Maturity 20 / 20
Attack Chain Potential 20 / 20
โš–๏ธ Divergence & Operational Rationale

[object Object]

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.


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");
}

In ARM64e Pointer Authentication, pointer signing instructions require two inputs:

  1. The pointer value (stored in a target 64-bit general-purpose register, e.g., x16 or x17).
  2. 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:

  • destinationRegister set to the address of their shellcode or ROP gadget chain.
  • tagRegister set to the exact modifier required by a high-value function pointer target (such as a Virtual Method Table pointer or wasmToEmbedderStub).

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.

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.cpp
MacroAssemblerCodeRef<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.


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. |
+-----------------------------------------------------------------------------------+
  1. 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 JSArray objects, giving the attacker arbitrary 64-bit memory read and write primitives within the com.apple.WebKit.WebContent address space.

  2. 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 wasmToEmbedderThunkGenerator entry point.

  3. 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].

  4. 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.

  5. 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.


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 WebContent
id: 5a8e2b9c-4f71-419b-89d2-cve202427834-sigma
status: production
description: Detects unexpected child processes spawned by Apple Safari WebKit WebContent renderer, indicating successful PAC bypass and native shellcode execution.
author: Hermes Codex Cyber Risk Intelligence
date: 2026-11-05
references:
- https://www.cisa.gov/known-exploited-vulnerabilities-catalog?search_api_fulltext=CVE-2024-27834
- https://support.apple.com/en-us/HT214106
logsource:
category: process_creation
product: macos
detection:
selection:
ParentImage|endswith:
- '/com.apple.WebKit.WebContent'
- '/Safari.app/Contents/MacOS/Safari'
Image|endswith:
- '/sh'
- '/bash'
- '/zsh'
- '/curl'
- '/osascript'
- '/python3'
- '/launchctl'
- '/plutil'
condition: selection
fields:
- ProcessId
- Image
- CommandLine
- ParentProcessId
- ParentImage
falsepositives:
- Custom browser automation suites or developer test harnesses in debugging mode
level: critical
tags:
- attack.execution
- attack.t1203
- attack.t1068
- cve.2024.27834
// Detect anomalous child process execution from WebKit WebContent on macOS
DeviceProcessEvents
| 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

To protect enterprise macOS and iOS fleets against CVE-2024-27834 exploitation:

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.

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.

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.