PC game developers have spent two decades defending the graphics pipeline from attackers who know how to exploit it.

On the one side, developers use capture tools to inspect meshes, textures, shaders, and rendering state before and after GPU processing.

On the other side, attackers turn that same visibility against a game, while injected graphics libraries let them go further by changing what gets drawn, removing visual obstacles, manipulating player highlights, or inserting overlays into the game itself.

Mobile game security has traditionally fought on different ground, defending game logic, safeguarding embedded secrets, and protecting the app at runtime. Now this battlefield is expanding into the graphics pipeline too.

Promon’s latest App Threat Report shows how Android’s Vulkan layer mechanism deserves more attantion as a route into the rendering path. PC techniques don’t simply transfer unchanged to Android. The platform and mechanism are too different. But PC cheating has already established an underlying lesson for Android. If attackers can inspect and manipulate the path between the game and the GPU, protecting game logic alone is not enough for defenders.

Read the report: App Threat Report Q3 2026: GPU debugger abuse in Android apps

PC showed why the graphics pipeline matters

Graphics debugging tools exist because developers need visibility into a part of the application that would otherwise be difficult to inspect.

When rendering breaks or performance drops, tools such as RenderDoc, PIX, and Nsight let developers examine shader execution, GPU memory, command buffers, pipelines, and draw calls. Those capabilities are great for helping developers find problems. Unfortunately, they also give cheat developers a detailed view of the complete graphics pipeline. How content is drawn. When an asset is decrypted. Every shader. Every frame.

Capture tools expose the rendering process

On PC, capture tools have long given attackers one route into that information. For example, a tool can record the GPU work behind a frame and expose the assets and rendering data that the hardware needs to use. 

The renderer has already done much of the preparatory work by this point. It places model data into vertex and index buffers. It uploads decoded textures in formats the GPU can sample. It passes shader bytecode to the driver. Attackers who capture the rendering process can inspect those assets in the usable form that reaches the GPU instead of working backwards through the game’s original storage formats and protections.

Injected libraries let attackers intervene

Injected graphics libraries give attackers even more control. An attacker can load a library into the game process, intercept graphics calls, and change them before they reach the GPU. A classic wallhack, for example, can identify the draw call for a player model and disable depth testing for that call. The GPU then draws the player on top of a wall that should hide them.

Attackers can use similar techniques to remove smoke, fog, particles, or foliage. Or they can add player markers and overlays that look as though the game itself rendered them.

Crucially, attackers don’t always need to alter the underlying game state. Because the manipulation happens after the game logic hands its work to the graphics stack, the game can hold the correct information while the graphics pipeline presents something different to the player.

PC game security has battled these problems for years.

Android gives a familiar attack class a different route

The important development on Android isn’t that attackers can simply copy a traditional PC injection technique onto a phone. Vulkan layers also run in-process on PC and other platforms. What changes on Android is the route into the app: classic PC injection techniques are much harder to use, while Android’s system loader provides a supported, gated way to load a Vulkan layer into an app.

from pc graphics abuse to android vulkan layers (2)

Vulkan keeps its core graphics API deliberately lean. Rather than build validation and diagnostic work into the API itself, Vulkan uses layers that sit between the application and the driver.

Developers use these layers for validation, debugging, frame capture, profiling, and other legitimate tasks. A layer can inspect a Vulkan call, modify it, or pass it to the next point in the chain.

On Android, GPU debug layer settings let the Vulkan loader load a layer as native code inside the target application’s process when Android’s conditions are met. A malicious layer is untrusted code, but it can still be loaded by a trusted component through a fully supported path.

The path itself is not new. Android has supported Vulkan layers since Android 7, while the settings for loading GPU debug layers into a debuggable app arrived in Android 9. What Promon’s research highlights is an under-examined security implication: this supported mechanism can also provide an unusually clean route for attackers to get code into the app process.

Our research team demonstrated one route on a rooted device. They influenced the Android framework so that it evaluated the target app as debuggable.

Once the app met Android’s layer-loading condition, the Vulkan loader mapped the layer into the app process through the normal supported mechanism. The team didn’t need to modify the target app for this route.

This is where the PC comparison becomes useful. Attackers on PC and attackers using an Android Vulkan layer follow different technical paths. But both want a similar position: visibility into the graphics pipeline and the ability to intervene.

When the game state is right but the frame is wrong

Anti-cheat systems have good reasons to focus on game state and process integrity. They look for modified memory, hooked functions, injected code, anomalous player behavior, and other evidence that someone has manipulated the game for unfair advantage.

Graphics-layer manipulation creates another problem. Attackers can leave the game logic alone and change what reaches the screen instead.

A malicious Vulkan layer can inspect the render command stream and alter draw or dispatch behavior. It can change which resources the renderer binds, insert extra draws, or manipulate post-processing.

Attackers can use that position to highlight objects, remove visual obstructions, or add content that the game never intended to display. Meanwhile, the CPU-side game logic continues to report the correct state. Validation and safety are not automatic.

the gap between game state and screen output

An anti-cheat system that validates only that logic may therefore see nothing wrong. Attackers make the change later in the path, after the checks that establish what the game believes should happen.

The App Threat Report puts the distinction bluntly:

“The lie is downstream of everything the anti-cheat checks.”

PC graphics cheats have exploited this separation for years. Promon’s research shows why mobile game security teams now need to include it in their own threat models.

Traditional injection checks are not the whole answer

Common anti-tamper techniques look for evidence that attackers have interfered with the application process.

  • An inline hook changes instructions.

  • A rewritten GOT or PLT entry redirects execution.

  • A trampoline creates an unexpected executable region.

  • Direct manipulation of GPU command buffers can leave evidence of a foreign module writing to the buffer.

Conventional injection usually leaves evidence that something has been altered. Security products know how to detect these artifacts, and those detections remain useful.

Vulkan layer injection can avoid many of these fingerprints because Android and Vulkan perform much of the work themselves.

Five reasons standard detections can miss Vulkan layer injection

Promon’s research is careful about the limits of that finding. As the report says:

“The honest limit: this is not invisible.”

The layer’s shared object still appears in /proc/self/maps, and an application can inspect its own Vulkan layer chain. If the app finds a layer that it never requested, that gives the security team a useful signal.

The important question is why many standard anti-tamper detections can still miss the technique. The App Threat Report identifies five reasons.

  1. Nothing is patched.

  2. The interception point is a function pointer the loader wrote itself.

  3. The ioctl traffic is genuine.

  4. Nobody writes into the submit buffer.

  5. The Vulkan layer loads before integrity checks run.

why standard injection checks can stay clean_edited

Because the Vulkan layer is itself a native library running inside the app process, it can also provide a foothold for more conventional tampering tools. The loader-mediated entry path may bypass some checks that would normally detect how those tools entered the process, although their subsequent behavior can still leave detectable artifacts.

The loader doesn’t need to patch the application’s code to insert the layer. It builds the layer dispatch table and writes the relevant function pointers as part of normal Vulkan operation.

The layer doesn’t need to issue suspicious GPU driver calls directly. It calls Vulkan functions such as vkCmdDraw, after which the vendor’s own driver encodes the work and submits it through its normal ioctl path.

The driver fills the GPU submit buffer too, so a detector does not see an unexpected module writing directly into that memory.

Timing creates another challenge. Vulkan loads the layer during instance creation, before much of the application’s own integrity code has started. By the time those checks run, the layer can already be inside the process. This is why standard anti-tamper checks may not see the usual signs of injection.

Root and debuggable-state detection are necessary but not sufficient. Promon used a rooted device and manipulated the app’s debuggable state to demonstrate the main attack path in the research, but again, explored other routes that did not require root access.

The broader lesson is that anti-cheat can’t rely on a generic set of injection fingerprints. If the operating system and graphics stack perform the loading through supported mechanisms, defenders need to inspect the runtime state the platform has created, including what has been loaded into the application and whether that state is expected. This is on top of looking for evidence of traditional hooking and repackaging. And as detailed in the App Threat Report, malicious code injection via the Vulkan graphics interface.

Learn more: Root detection: What it is and how it works

What mobile game security can take from PC

PC cheating has already shown what attackers can do when they gain leverage over the graphics pipeline. Extract assets and study how the renderer works. Change what the player sees without necessarily changing what the game believes. Use legitimate graphics mechanisms as part of an attack.

There is another important point in the App Threat Report:

“There is no vulnerability in this writeup.”

The attack comes from combining a supported extensibility mechanism with an environment in which attackers can influence the conditions that control it. That makes this a different problem from a vulnerability that disappears once a vendor releases a patch.

There’s no need for mobile game teams to copy the PC threat model wholesale. What they do need is to account for the same class of problem, because Android’s graphics stack provides a supported route into the rendering path. This starts with treating the graphics pipeline as part of the game’s attack surface rather than simply the place where trusted game logic produces a picture.

Security teams also need visibility into what the platform loads into the application. Checking the Vulkan layer chain can reveal an unexpected layer even when conventional code-integrity checks remain clean. Root and debuggable-state checks add further context about whether attackers have created the conditions needed for abuse.

Runtime integrity needs to cover the path from the game’s internal state to the frame the player actually sees, including checks for Vulkan layers.

Repackaging in gaming remains a common method for hackers when pivoting their techniques. And modifications to the Operating System (OS) allow for system-wide abuse of layers.

PC cheating gives mobile teams two decades of warning. Android’s Vulkan layer mechanism gives them another reason to act on it.

Promon’s App Threat Report Q3 2026: GPU debugger abuse in Android apps explains the research in full, including how Vulkan layers work, how Promon demonstrated the attack path, what attackers can gain from it, and why standard anti-tamper detections can miss Vulkan-specific code injection attacks.

Read the report: App Threat Report Q3 2026: GPU debugger abuse in Android apps

If you ship a Vulkan renderer on Android and your threat model stops at repackaging and process injection, the layer chain deserves an afternoon of your attention.

Protect your mobile game at runtime
Stop attackers from manipulating your game or abusing the rendering path. Talk to us about strengthening your runtime protection against cheating and injection.
Book at meeting