/

CVE-2026-49269

Severity:

HIGH RISK

(8.6)

GPU Register Data Exposure (CWE-200) on Apple M1

CVE-2026-49269

Awaiting Analysis

Vulnerability type

Category:

Information Disclosure

CWE:

CWE-200

Impact:

Cross-process secret leakage via GPU registers

Severity:

HIGH RISK

(8.6)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A data exposure flaw in Apple M1 GPUs allows register file contents to persist across Metal compute shader dispatches from different sandboxed processes. A malicious Metal app can read stale GPU register values and recover secrets processed by another sandboxed app. The issue becomes risky when sensitive data, such as cryptographic material, is loaded into GPU registers and multiple untrusted apps share the same GPU hardware.

Affected context

This vulnerability occurs in environments where multiple sandboxed applications use Metal compute shaders on legacy Apple M1-class GPU hardware. It becomes relevant when sensitive values, like random secrets or cryptographic keys, are placed into GPU registers and the underlying hardware does not fully clear register state between dispatches for different processes. Systems with untrusted or multi-tenant workloads sharing GPU resources are more exposed to this risk.

Exploit preconditions

  • Attack surface: Local GPU compute interface via Metal.
  • Required access: Ability to run a sandboxed Metal-enabled application on the target system.
  • Trigger point: Execution of a specially crafted GPU "reader" shader after a victim app has performed GPU computations involving sensitive data.
  • Why exploitation is possible: Legacy Apple M1 GPU hardware retains stale register file contents across process boundaries, allowing subsequent shaders to read residual values that were never explicitly cleared.

Why this happens

The root cause is a hardware-level information disclosure issue where GPU register files are not reliably cleared or reinitialized between compute dispatches from different processes. This aligns with CWE-200: Exposure of Sensitive Information to an Unauthorized Actor, because the GPU execution environment unintentionally exposes prior register state to later workloads. Abstractly, the pattern is shared hardware state that persists across isolation boundaries, allowing one tenant to observe another tenant's intermediate computation data in violation of expected sandbox guarantees.

Potential impact

  • A malicious app may recover cryptographic secrets processed on the GPU by another sandboxed app.
  • Attackers could infer sensitive application data, such as random tokens or key material, from residual register state.
  • GPU-based security or privacy mechanisms can be undermined by unintended cross-process data leakage.
  • Multi-tenant or shared GPU environments may experience weakened isolation between workloads.

General mitigation guidance

Mitigation generally focuses on reducing the amount and lifetime of sensitive data in shared hardware state and enforcing stricter isolation. Common defensive patterns include:

  • Avoiding storage of long-lived cryptographic secrets or highly sensitive data directly in GPU registers when multi-tenant GPU usage is possible.
  • Designing GPU workloads to minimize residual state, including explicit overwriting of temporary buffers and use of algorithms that do not rely on persistent register values.
  • Applying a defense-in-depth model where cryptographic operations are confined to better-isolated components (e.g., CPU secure enclaves) instead of general-purpose GPUs.
  • Restricting GPU access for untrusted apps in high-assurance environments and applying least-privilege policies to GPU-accelerated computation paths.

How teams detect issues like this

Detection is primarily analytical and configuration-focused rather than signature-based. Organizations can:

  • Review GPU-accelerated code paths for handling of cryptographic keys and other sensitive material that may reside in registers or temporary GPU memory.
  • Apply code review policies that flag designs relying on GPUs for secret generation or storage, especially in multi-tenant or shared device scenarios.
  • Use hardware and platform documentation to identify legacy devices with weaker isolation guarantees and treat them as higher-risk in threat models.
  • Employ security testing or research frameworks that probe for cross-process data leakage on accelerators to validate isolation assumptions.

Sources

SourceLink
gist.github.comgist.github.com/scndls/9cbe31f2b0b1578eaeb311e601335355

Frequently asked

questions

No. Exploitation requires the ability to run a local Metal-enabled application on the same system and share the GPU hardware with a victim application.

An attacker needs the ability to install or execute a sandboxed app that uses Metal compute shaders. No special privileges are required beyond standard app execution capabilities.

The safest pattern is to prevent sensitive secrets from being processed or stored in GPU registers on hardware that cannot guarantee isolation. Prefer performing cryptographic operations in components with strong clearing and isolation guarantees, and treat GPUs as untrusted for key material.

Design systems assuming shared accelerators may leak residual state, enforce strict threat modeling for GPU and accelerator usage, minimize sensitive data in shared hardware resources, and rely on hardware that provides documented register clearing and robust tenant isolation guarantees.

Find out what's already
exploitable in your codebase.