Skip to main content
Be Bitwise

Modern Mitigation Challenges

Exploit Mitigation Bypass Techniques · Exploit Development track

6 min read

In this module

The Cutting Edge

ARM Pointer Authentication (PAC), Intel Control-flow Enforcement Technology (CET), and ARM Memory Tagging Extension (MTE) are in production hardware today — they're not future proposals. Understanding how researchers approach these mitigations, and the bypass work that's already emerged, shows you the actual frontier of the attacker-defender arms race.

ARM PAC Bypass Research

ARM PAC signs pointers using hardware keys, adding a cryptographic Pointer Authentication Code to unused upper bits. Authenticated pointers must pass verification before use. The security of PAC depends on the attacker's inability to forge valid PACs.

PAC signing oracles: If the attacker can trigger code that signs a pointer they control, they can obtain a valid PAC for their chosen address. Functions that take a pointer argument, sign it, and store or return it are signing oracles. Researchers look for these oracle gadgets in the target's code.

The life of a signed return address shows where the oracle fits. The legitimate path signs and authenticates; the attacker's two options are to forge a PAC, which fails, or to get the program to sign their pointer for them:

Key diversity: PAC has five keys (IA, IB, DA, DB, GA) for different pointer types. If a program uses the same key for multiple pointer types, compromising one type gives the attacker valid PACs for the other.

Speculative execution: The PACMAN attack demonstrated that PAC values can be leaked through speculative execution side channels. The CPU speculatively executes past a PAC check, and the attacker observes cache side effects to determine whether the speculated PAC was valid, effectively brute-forcing the PAC without crashing the program.

Intel CET Challenges

CET provides both Indirect Branch Tracking (IBT) and Shadow Stacks. IBT requires indirect branch targets to begin with ENDBR64. Shadow stacks store return addresses in hardware-protected memory.

ENDBR64 proliferation: Because IBT is coarse-grained, every function entry point is a valid target. Large binaries like libc have thousands of ENDBR64 markers. An attacker who achieves a write-what-where primitive can redirect any indirect call to any function with ENDBR64, which includes many useful functions for building exploit chains.

Shadow stack manipulation: The INCSSP instruction adjusts the shadow stack pointer, allowing a thread to pop entries from the shadow stack without returning. While INCSSP is designed for legitimate purposes (like longjmp and C++ exceptions), it could potentially be abused to desynchronise the shadow stack.

Transition to ring 0: CET shadow stacks operate differently in kernel mode versus user mode. The transition between modes is a complex attack surface that researchers continue to examine.

Fine-Grained CFI on Top of IBT

Type checks on top of IBT already exist, done in software. Clang's kCFI (-fsanitize=kcfi) stores a hash of each function's type just before its entry point and checks it at every indirect call. The Linux kernel's FineIBT, added for x86 in Linux 6.2, combines that kind of type hash with IBT's ENDBR64 landing pads, so a target must be a valid entry point and also have the expected type. The hardware still only enforces the coarse part; the precision comes from the compiler.

MTE Bypass Research

ARM Memory Tagging Extension (MTE) assigns a 4-bit tag to every 16-byte granule of memory and carries a matching tag in the top bits of each pointer. Every memory access checks that the pointer's tag matches the memory's tag. A mismatch triggers a fault. MTE catches both spatial (overflow into differently-tagged memory) and temporal (use-after-free where the freed memory was re-tagged) bugs.

4-bit tag space: Only 16 possible tag values means roughly a 1-in-16 chance that a random pointer carries the correct tag. Tag 0 is special in practice: it's what untagged memory carries, and on Linux the random-tag instruction generates only tag 0 until a process opts other tags in, so allocators choose which values they use and the real odds depend on that choice. For reliable exploitation, the attacker needs a tag oracle or a way to predict the allocation pattern.

Tag prediction: Some allocators generate tags deterministically. An attacker who maps the pattern can construct pointers that pass the check.

Synchronous vs asynchronous mode: MTE can run synchronously (fault immediately on mismatch) or asynchronously (defer reporting for better performance). Asynchronous mode leaves a window where the bad access succeeds before the kernel even notices.

Kernel MTE: MTE in the kernel is particularly challenging because kernel objects share the same tagged address space, and the tag checking overhead interacts with interrupt handling and DMA.

How Researchers Approach New Mitigations

The security research community follows a systematic process when new mitigations appear:

  1. Study the specification: Read the hardware documentation thoroughly to understand the exact guarantees and explicit non-guarantees
  2. Identify the threat model: What attacks does the mitigation claim to prevent? What is explicitly out of scope?
  3. Examine the implementation: How do compilers, OS kernels, and applications use the mitigation? Implementation gaps often differ from the hardware's theoretical capability
  4. Look for interaction bugs: How does the mitigation interact with other CPU features (speculation, interrupts, power management)?
  5. Test edge cases: Signal handling, thread migration, exception paths, and legacy compatibility modes are rich sources of bugs
  6. Evaluate adoption: Is the mitigation enabled by default? Do all components use it consistently? Partial adoption leaves gaps

The Trend: Raising the Cost of Exploitation

No mitigation is unbreakable. The goal is to make exploitation progressively more expensive:

  • Pre-ASLR era: a single buffer overflow was enough for reliable exploitation
  • ASLR era: exploitation needs an additional info leak
  • DEP era: exploitation needs ROP or equivalent code reuse
  • CFI era: exploitation needs type-compatible targets or data-only attacks
  • PAC/MTE era: exploitation needs hardware-level bypasses or side-channel attacks

Each generation kills the cheapest techniques, forcing attackers toward methods that are more complex, more brittle, and harder to automate. The shrinking pool of viable approaches is the actual metric of defensive progress — not whether exploitation is impossible, but how expensive it has become.

The Asymmetry of Security

Defenders must protect every path. Attackers need only one working path. This asymmetry means that even imperfect mitigations have value if they eliminate large classes of attacks. A mitigation that stops 95% of exploitation techniques is enormously valuable even if researchers eventually find the other 5%. The goal is to stack enough imperfect layers that the combined defence becomes practically unbreakable for most adversaries.