Skip to content
Cerberus

Learn

Can AI reverse engineer my software?

Yes, an AI agent can reverse engineer unprotected software, and it can get through some protected software too. What it does well, where it fails, and what that means for anything you ship.

Updated

The short answer

An AI agent can reverse engineer unprotected software quickly, and it can get through lightly protected software. Against layered protection it mostly fails or runs out of budget. What it is good at is volume: it tries a lot, cheaply, without needing an expert.

How does an AI agent reverse engineer a program?

It works like a fast, tireless junior analyst. Given a compiled file and a goal, such as finding a hidden string or the license check, an agent typically:

  1. runs a disassembler or decompiler and reads the output,
  2. looks for the data it wants and the code that uses it,
  3. rewrites that code as a script it can run on its own,
  4. runs the script and reports the result.

When reading looks too expensive, it switches to running the program under an emulator or debugger and watching what happens. In every run Quarkslab published, the agent went around the protection rather than through it.

What is AI good at in reverse engineering?

Reading ordinary code and explaining it. Decompiled output from an unprotected program, especially Java or .NET bytecode, is close to source code to a model. It names functions, guesses types and points to the branch that decides whether the program runs. That makes a client-side license check the first thing an agent finds.

It is also good at persistence. An agent does not get bored, and it can run many attempts in parallel. For a vendor, that means more attempts against every release, from people who could not have made one before.

Where does AI reverse engineering fail?

On code that is too expensive to read and offers no shortcut. In Elastic’s benchmark the model solved every unprotected sample, about half of the samples with a single obfuscation transform, and none of the most heavily layered ones. Most failures came from the agent burning its budget going in circles.

The public research points at a few consistent weaknesses:

  • Size. Transforms that blow up the size and branching of a function hurt a model more than ones that only add indirection.
  • Execution. Agents are much stronger at reading than at running code they do not understand. Protection that only reveals itself at runtime is hard for them.
  • Verification. Agents tend to stop at an answer that looks right. Both studies saw confident reports that did not match what the agent actually did.

What protection actually holds up?

Layered obfuscation, runtime anti-tamper and server-side licensing, together. Obfuscation pushes the agent off the cheap path. Runtime checks defend the program once it has to be executed. Licensing on the server means that even a fully understood build does not unlock anything by itself.

Read the full argument in software protection for the age of AI reverse engineering, and see how a license check moves off the client in server-side license validation.

What this does not tell you

These studies used specific models, budgets and test programs. A determined human expert, or a better-funded agent, will go further than a benchmark does. The results describe cost, not certainty: protection made attacks much more expensive, not impossible.

Questions

Can ChatGPT or Claude decompile an executable?
Not on their own. A chat model cannot run a decompiler. An agent with a shell can: it runs a disassembler or decompiler, reads the output and writes scripts against it. Pasting decompiler output into a chat window gets you an explanation of that output, which is often enough for unprotected code.
Is a Java or .NET app easier for AI to reverse engineer than a native one?
Usually, yes. JVM and .NET bytecode decompiles back to readable code with names and types largely intact unless it is obfuscated. Native machine code loses more information at compile time, so both people and models start from a harder place.
Does renaming classes and methods stop an AI?
Barely. Models infer what a function does from its structure, the calls it makes and the strings it uses. Renaming removes a hint a human relied on, but a model rarely needed it.
What kind of protection makes AI agents fail?
Protection that makes reading the code too expensive and leaves no shortcut. In public tests, stacked transforms such as control-flow flattening combined with arithmetic obfuscation, runtime code generation and nested virtualization caused agents to fail or run out of budget.
Will this stay true as models improve?
Partly. Better models will read more per attempt and get better at running code instead of only reading it. Protection that is varied per build and keeps its secrets on a server holds up better over time than any single transform.

Sources

  1. Defeating AI-Assisted Reverse Engineering (or at Least Trying To), Quarkslab, August 2026
  2. The Cost of Understanding: LLM-Driven Reverse Engineering vs Iterative LLM Obfuscation, Elastic Security Labs, April 2026