The Unfixable ARM Memory Bug

ARM’s Memory Tagging Extension (MTE) is designed to stop memory corruption by crashing the CPU when a pointer’s embedded tag doesn’t match the tag on the memory it’s accessing. A new research effort demonstrates a path to bypass that protection on ARM systems anyway—by combining speculative execution with a cache side channel to infer the correct memory tag, then using the recovered tag to make the protected access succeed. The result is a “memory bug” that isn’t just a software flaw; it targets a core hardware security mechanism meant to be robust against exactly this class of exploitation.

The attack builds on two realities of modern CPUs. First, memory corruption bugs like buffer overflows remain a common entry point for control-flow hijacking, because overwriting return addresses can redirect execution. Second, speculative execution—introduced to keep performance high when branch predictions are wrong—can temporarily perform operations that should not architecturally complete. Even when speculative paths are discarded, microarchitectural effects (especially cache behavior) can still leak information.

MTE works by attaching a tag to pointers and requiring that tag to match the tag associated with the target memory on every load and store. If the tags mismatch, the CPU raises an exception, preventing the corrupted access from proceeding. The researchers’ key move is to make the CPU speculatively dereference pointers in a way that would normally trigger a tag mismatch—yet avoid the crash because the faulting behavior doesn’t become architecturally visible during speculation. Instead, the attack measures whether a “test” pointer’s access caused the relevant cache lines to be filled. By timing those cache effects, the attacker can determine whether the guessed tag was correct.

Concretely, the method uses a speculative gadget: a code pattern that creates two pointers within the same 16-byte memory block so they share the same underlying tag context, then speculatively dereferences a guest pointer (the target) and a test pointer (controlled by the attacker). If the test pointer’s tag guess is wrong, the CPU won’t bring the corresponding data into cache in the way the attacker expects. If the guess is right, cache fill timing changes. Repeating this process lets the attacker iterate through candidate tags until the correct one is inferred.

Once the correct MTE tag is learned, the attacker can “launder” a pointer—effectively reconstructing a pointer that will pass MTE checks—and then proceed with traditional exploitation goals like stack smashing. The work also shows the technique can be carried out inside the V8 sandbox environment (the JavaScript engine used by Chrome and Node.js), by identifying “MTE leak gadgets” within V8 code paths that provide the needed speculative behavior. That combination—hardware protection bypass plus sandbox escape potential—raises the stakes beyond a theoretical CPU quirk, because it suggests the mitigation can be undermined in real-world, widely deployed software stacks.

Overall, the core finding is that MTE’s promise (“mismatched tags crash”) can be defeated when speculative execution and cache timing are used together to recover the tag before the protected access occurs. It’s a reminder that performance features built into CPUs can become security liabilities when attackers can measure the side effects they leave behind.