On autonomous reverse-engineering

Disclaimer: The views expressed in this blog post are my own and only my own. They are based on my personal experiences and reflections.

If there's one thing I've been passionate about throughout my career, it's reverse-engineering. I've also enjoyed teaching reverse-engineering for years, either in-person or when developing online courses. One of the things that struck me as time passed by was how much tooling has changed the way we work. 

I remember senior reversers telling me around 2010 how they (rightfully) didn't trust the decompiler because it would constantly produce erroneous code, or miss basic blocks entirely. I remember how never pressing F5 in IDA was a point of pride back then -- the testament of a true craftsman. Ten years later though, especially as Ghidra became more mainstream, I found myself wondering whether it still made sense to teach assembly basics to students, especially as it would only resonate with 5% of them. I kept shoving ASM down their reluctant little throats on the grounds that decompilers might still make some mistakes on rare occasions, and that you still need to go down to that level on a semi-regular basis, when using a debugger to shed some light on any function that you can't crack statically. I'm willing to admit there may have been a hint of elitism in there as well.

Shortly thereafter LLM models took over the world and it became immediately obvious that they were extremely good at reverse-engineering. Gepetto's evolution reflected the successive steps we made in the field: first copy-pasting decompiled code into ChatGPT, then figuring out that we could go even further by exposing tools to the LLM. And if you've been paying attention, you've probably started hearing about AI doing autonomous malware analysis ; one of the rare AI x cyber applications that is neither overblown nor totally BS.

How I feel about all this

It feels obvious to me that reverse-engineering is on the verge of its MidJourney moment: the point in time at which available tooling empowers anyone to achieve something only seasoned professionals could before. There have been many times in the last 3 years where I thought AI had hit a wall it could never break: LLMs will never produce convincing music, they will never find vulnerabilities on their own, deepfakes will never be quite convincing enough. I have been wrong often enough that I have learned better than to bet against progress in the AI field. My money is now on the fact that fully autonomous reverse-engineering will happen, likely sooner than we think.

This all makes my personal feelings very irrelevant: sure, there might be a part of me feeling sadness that my craft will gradually become irrelevant, but also I've been growing more and more bored of looking at malware samples that all do variations of the same thing. I have no doubt threat actors are using LLMs to unleash massive quantities of low-quality malware samples onto the world, and it feels only fair that we use the same technology to process them. There will always be a need for manual review and analysis somewhere in the chain, but the way we work is about to change for sure. 

Sometimes we want things to stay the same, but they just don't.

Enter Gepetto Web (name TBD)

Anyway, I've been trying to stay one step ahead in this game, and have been quietly working on autonomous RE in my spare time, partnering with Hex-Rays. The result is an online portal where people can submit files and get a full analysis of the file, powered by a state-of-the-art LLM. I'll be candid about the results:

• For "simple" samples (C stagers, downloaders, etc.), the result is really good. In the time it takes for you to get a coffee, you get the equivalent of what used to take a couple of hours of work.
• For bigger samples in more difficult languages (ex: Go / Rust), I've had convincing results as well, with the model being able to capture the general intent.
• I haven't explored packed samples too much, but initial testing shows that they're very resistant to this type of analysis. There may be a need for a dedicated unpacking agent.
• So far, LLMs seem to struggle on decryption and decoding of strings and have problems dereferencing pointers to access cryptographic materials. That's my current area of focus.

Here is the summary output of an old stage 2 (written in C) which confirms the previous statements: the model did a great job identifying features and describing what the program does, but it struggles with config extraction:

This sample is a Windows GUI malware that implements an HTTP‑based remote shell / downloader using an unusual custom block cipher plus custom Base64. It:
    - Persists by adding itself to a user‑level autorun registry key.
    - Periodically contacts a hardcoded HTTP C2 server to fetch a “command” string (base64‑encoded and then decrypted).
    - Interprets that command to:
        - Launch a hidden cmd.exe whose stdin/stdout are proxied over HTTP.
        - Or sleep for an operator‑specified number of minutes.
        - Or download and execute an arbitrary payload from a URL.
    - Uses HTTP GET both as a control channel (fetching new commands) and as a data exfiltration path (cmd output).
    - Encodes all HTTP‑related strings (C2 URL, user‑agent, registry path, command line for cmd.exe, etc.) with a custom DES‑like bitwise block cipher, and then uses a non‑standard Base64 alphabet for some payloads.
The program’s entry point is the usual CRT start at start (0x4020... via IDA symbol), which eventually calls WinMain at 0x401A... (WinMain symbol renamed from _WinMain@16).
[In-depth sample analysis follows.]

For now, I have found that the best way to build on top of this is to let the user download the annotated IDB to continue with the analysis on their own if they so choose. I expect that as progress is made, this will be less and less useful.

Trying it out

The paint is still very fresh, but I'm ready to open the platform for a private beta. If you're interested in joining, just DM me on Twitter and I'll give you access as well as credits so you can run a few analyses. All I ask in return is that you provide some feedback on the things that don't work for you, or that could be made better.