Deixei uma IA fazer engenharia reversa de um binário de jogo e depois avaliei o resultado

Autoria: Prompt Engineer 48 · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: I Let an AI Reverse-Engineer a Game Binary, Then I Graded It · Canal: Prompt Engineer 48 · 06:42 · Assistir no YouTube

Tópicos: Agentes de IA, Avaliação e benchmarks de IA, Cibersegurança e segurança de software, Open source e ecossistemas de software

Resumo

O vídeo testa o REA, um servidor MCP que permite a um agent analisar binários, usando uma versão compilada e sem símbolos do OpenTTD 15.3. Na primeira tentativa, o agent identificou corretamente estruturas e motivos de encerramento de segmentos de rota, mas errou ao afirmar que não havia strings relacionadas a penalidades. Com pistas adicionais, encontrou a fórmula de custo de rota e mapeou 24 configurações, e o autor conferiu essas descobertas com o código-fonte real. O vídeo também mostra limites do teste: os valores padrão não foram encontrados, e a implementação criada a partir das descobertas não reproduz todos os aspectos do jogo.

Pontos-chave

REA é um servidor MCP que usa ferramentas como Ghidra, Hopper ou IDA para analisar programas compilados.
O teste usou OpenTTD 15.3, por ser open source, com um binário compilado pelo autor e sem símbolos exportados.
A primeira análise encontrou 13 motivos para um segmento de rota terminar, todos na ordem correta, mas errou ao negar a existência de strings sobre penalidades.
Na segunda tentativa, com pistas sobre strings e offsets, o agent identificou a fórmula de custo e mapeou 24 configurações.
O agent não encontrou os valores padrão e concluiu corretamente que eles são preenchidos durante a execução.
Uma implementação independente passou em 10 testes derivados da especificação, mas esses testes validam a leitura da especificação, não a equivalência com o jogo.
O clone ainda difere do jogo: sua penalidade de inclinação também se aplica na descida, e não inclui reserva de sinais nem comprimento de plataformas.
As quatro execuções do agent custaram, juntas, US$ 4,39.

Capítulos

Início	Capítulo	Resumo
00:00	Apresentação do REA e escolha do jogo	O autor apresenta a ferramenta, suas limitações declaradas e a decisão de testar com OpenTTD em vez de um jogo pago.
01:02	Preparação do binário e do ambiente	O teste é isolado no WSL 2, e o binário é recompilado sem os símbolos exportados que ainda revelavam nomes de funções.
02:35	Primeira análise e correção de um erro	O agent identifica estruturas de rota e o algoritmo A*, mas deixa passar strings de penalidade e precisa de uma nova tentativa.
04:06	Fórmula de custo e demonstração do clone	Com pistas adicionais, o agent encontra a fórmula e 24 configurações, que servem de base para uma implementação testada em dez casos.
05:41	Limitações e conclusão	O agent não encontra os valores padrão, e o autor detalha diferenças entre o clone e o jogo antes de resumir o custo e os resultados.

Citações

A fórmula por trás desse número foi extraída de um arquivo do jogo sem código-fonte nem símbolos por um agent de IA. — 00:00

Como um trem escolhe sua rota em um entroncamento, e mostre evidências para cada afirmação. — 03:05

Estava confiante e estava errado. — 03:36

Essa é a resposta certa, mesmo que não seja a que eu queria. — 05:41

Conceitos e entidades

REA (ferramenta): Servidor MCP que coordena ferramentas de engenharia reversa para analisar programas compilados.
OpenTTD (repo): Jogo open source usado no teste para comparar as descobertas do agent com o código-fonte real.
Ghidra (ferramenta): Ferramenta de análise de programas compilados usada pelo REA durante o teste.
Claude Code (ferramenta): Ferramenta configurada para chamar o REA por meio de uma entrada MCP.
A* (conceito): Algoritmo de busca que o agent reconheceu como o método usado para encontrar rotas.
WSL 2 (ferramenta): Ambiente Ubuntu no Windows em que o autor executou o teste isolado.

Tradução completa (pt-BR)

00:00 Este trem acabou de fazer um desvio por causa de um sinal vermelho, e calculou o custo desse desvio como 1984. A fórmula por trás desse número foi extraída de um arquivo de jogo sem código-fonte nem símbolos por um agent de IA. Certo, neste vídeo vou mostrar como e onde ele travou. Vale lembrar que tudo isso foi executado em uma sandbox no meu laptop. A ferramenta se chama REA. Ela está no GitHub, sob Morluto, e o nome significa engenharia reversa de qualquer coisa. É um servidor MCP, o que significa que um agent como Claude Code pode chamá-lo e, por baixo dos panos, ele

00:31 controla o Ghidra, o Hopper ou o IDA para ler programas compilados. A licença é MIT. Agora, antes de executar qualquer coisa, uma observação: os números de estrelas que encontrei não batem. Minhas anotações diziam 25.000 em um dia, a página do repo mostrava cerca de 124.000, e um diretório de skills mostrava 14.000. Não posso dizer qual está certo, então não vou citar nenhum. O que posso dizer é que o pacote NPM foi criado em 12 de julho, então tem cerca de três meses, não um dia. E o próprio aviso diz que ele não

01:02 ajuda a copiar software proprietário nem a contornar DRM. Isso importa para a próxima parte. Primeiro, eu queria fazer isso com RimWorld, mas não sou dono do jogo e, considerando esse aviso, desmontar um jogo pago e cloná-lo é exatamente o tipo de coisa em que a ferramenta diz que não vai ajudar. Então, mudei para a versão 15.3 do OpenTTD. Ele é open source, então posso compilar o binário por conta própria, remover os símbolos dele e entregar ao agent apenas o arquivo sem símbolos; depois, deixo o código-fonte real de lado para conferir cada afirmação que ele fizer. Esse é o teste todo. Tudo é executado dentro do WSL 2 Ubuntu

01:34 nesta máquina. Desativei as montagens das unidades do Windows e a internet. Então, se você olhar aqui, a montagem da unidade C está vazia e a ferramenta não consegue acessar meus arquivos. Primeiro, tentei executar o pod de CPU do Pod, mas não havia capacidade naquele data center, então optei pelo WSL. O Ghidra 12.1.4 está funcionando. O Node está na versão 24.21. E uma coisa que fiz diferente do arquivo readme: não executei o comando completo de configuração. Adicionei o REA ao Claude Code como uma única entrada MCP por conta própria, para saber exatamente o que mudou. Depois, executo o

02:05 agent com apenas as ferramentas do REA ativadas. Sem shell, sem acesso a arquivos, sem web. Agora, removi os símbolos do binário, então não há informações de depuração nem símbolos, e depois procurei nele a palavra Yapf, que é o nome do localizador de caminhos do OpenTTD. E você pode ver que ele ainda encontra nomes completos de funções, como Yap train choose track. Então, remover os símbolos não é suficiente neste caso. O jogo é vinculado com uma flag chamada RDynamic, que deixa 19.080 símbolos exportados no arquivo. Fiz a vinculação novamente sem essa flag, e as exportações caíram para 55. Esse é o

02:35 arquivo que usei no teste de verdade. Há mais uma coisa que vale mencionar. 11 strings do compilador ainda mencionam uma função chamada add new node com os tipos de track follower. Programas reais deixam escapar coisas assim, então mantive essas strings. Além disso, a primeira análise levou cerca de 17 minutos no Ghidra, e o prazo padrão do REA é de 330 segundos. A execução expirou. O readme menciona uma configuração para isso, REA_GhidraStartupTimeoutMS, e aumentei o valor para 45 minutos. A pergunta era simples. Como um

03:05 trem escolhe sua rota em um entroncamento, e quais evidências sustentam cada afirmação? 52 turnos, 19 minutos, 97 centavos. O que ele encontrou: seis campos de um segmento de caminho e 13 motivos pelos quais um segmento pode terminar, decodificados um a um a partir de uma tabela de strings. Conferi todos com o código-fonte real: 13 de 13 na ordem certa. Ele também encontrou o nó de busca, o pai, a estimativa de custo e os contadores de sinais, e disse que parecia uma busca best-first. Está certo: é A*.

03:36 Mas ele não encontrou a fórmula de custo, e disse isso. E houve uma afirmação que ele errou. Ele me disse que o binário não tinha strings de penalidade, nada parecido com real slope. Mas elas estão bem aqui: real slope penalty curve 90 first red. Ele estava confiante e estava errado. Então, fica o lembrete: confira também as afirmações negativas. Para a segunda execução, corrigi isso. Avisei que essas strings existiam e passei os deslocamentos da primeira execução. Então, vale lembrar: desta vez ele não está trabalhando às cegas, e bloqueei o acesso ao código-fonte real, para que o usuário do agent não possa lê-lo. A permissão é negada. Eu conferi.

04:06 28 minutos, 84 turnos, US$ 2,26. E aqui está o resultado. Ele descobriu que cada configuração tem uma função minúscula que retorna um deslocamento dentro de um objeto de configurações e mapeou todas as 24 configurações para deslocamentos: oito seguindo os nomes, 14 pela ordem dos stubs. Conferi todas com a struct real: 24 de 24. Depois, os custos: um trecho reto custa 100, um trecho diagonal custa 71, uma curva de 45° acrescenta uma penalidade, e uma curva de 90° acrescenta outra. Inclinação, cruzamento, estação, sinais vermelhos

04:38 e um bônus para sinais verdes; e a estimativa de distância: a menor das duas distâncias multiplicada por 71, mais a diferença menos um, multiplicada por 50. Essa é exatamente a fórmula real. O que ele não encontrou foram os valores padrão. Já volto a isso. Agora, escrevi uma especificação usando apenas o que o agent encontrou. Onde o agent não estabeleceu algo, sem consultar o código-fonte do jogo, a especificação diz que há uma lacuna. Depois, criei um localizador de caminhos. Dez testes, com os custos calculados à mão a partir da especificação. Uma linha reta custa 400 em quatro tiles. O teste de virar para o sul e depois para o leste é

05:10 171 + 71 + 200 + 100. Todos passam. E esta é a página. O trem começa aqui, a estação fica ali, e há um sinal vermelho na rota mais curta. Então, ele faz o desvio e o total é 1984. Se eu mudar esse sinal para verde, a rota segue em linha reta e o custo cai para 500, porque um sinal verde dá um bônus. E, se eu fizer dele um sinal vermelho de saída, a penalidade é 10.000. Então, ele dá outra volta. Você pode mudar as penalidades com estes controles deslizantes e observar a rota mudar. Vamos executar o trem.

05:41 Fiz mais duas tentativas para descobrir os valores padrão. Qual é o valor padrão da penalidade de inclinação? A primeira tentativa parou na metade porque minha conta atingiu o limite de uso. A segunda terminou em 21 minutos e custou 57 centavos, mas não encontrou nada. Ele disse que o código de registro não contém um valor padrão e que o objeto de configurações está vazio no arquivo, então os valores são preenchidos em tempo de execução. E se recusou a adivinhar. Essa é a resposta certa, mesmo que não seja a que eu queria. Então, o clone usa os valores padrão publicados do jogo, e a página deixa isso claro. E há mais três coisas que preciso contar.

06:11 A penalidade real de inclinação só se aplica ao subir, mas a minha se aplica nos dois sentidos. Não implementei a reserva de sinais nem os comprimentos das plataformas, e não testei meu clone no jogo real com a mesma disposição dos trilhos. Então, esses dez testes verificam minha interpretação da especificação, não do jogo. Neste vídeo, vimos como um agent consegue extrair a estrutura, a fórmula de custo e 24 configurações de um arquivo de jogo sem símbolos, e também onde não conseguiu. As quatro execuções do agent custaram, juntas, US$ 4,39. Se tiver interesse, você pode experimentar o REA em um programa que você mesmo criar e me contar como

06:42 foi. Vejo você em outro vídeo. Confira o próximo vídeo.

Transcrição original

[00:00] This train just took a detour because of a red signal and it worked out the cost of that detour as 1984. The formula behind that number was pulled out of a game file with no source code and no symbols by an AI agent. All right, in this video I’ll show you how and where it got stuck. Mind you, all of this ran in a sandbox on my laptop. So, the tool is called REA. It’s on GitHub under Morluto and it stands for reverse engineer anything. It’s an MCP server, which means an agent like Claude code can call it and under the hood it

[00:31] drives Ghidra, Hopper, or IDA to read compiled programs. The license is MIT. Now, before I run anything, one thing, the star numbers I found don’t agree. My notes said 25,000 in a day, the repo page showed about 124,000, and a skills directory showed 14,000. I can’t tell you which is right, so I won’t quote one. What I can tell you is the NPM package was created on the 12th of July, so it’s about 3 months old, not a day old. And its own disclaimer says it won’t

[01:02] help with copying proprietary software or getting around DRM. That matters for the next part. I first wanted to do this on RimWorld, but I don’t own it and reading that disclaimer, taking apart a paid game, and cloning it is exactly what the tool says it won’t help with. So, I switched to OpenTTD version 15.3. It’s open source, so I can build the binary myself, strip it, and give the agent only the stripped file, and then I keep the real source on the side to check every claim it makes. That’s the whole test. Everything runs inside WSL 2 Ubuntu on

[01:34] this machine. I turned off the Windows drive mounts and the interrupt. So, if you look here, the C drive mount is empty and the tool can’t touch my files. I tried to run pod CPU pod first, but there was no capacity in that data center, so I went with WSL. Ghidra 12.1.4 is healthy. Node is 24.21. And one thing I did differently from the readme, I didn’t run the full setup command. I added REA to Claude code as a single MCP entry myself, so I know exactly what changed. Then I run the

[02:05] agent with only the REA tools turned on. No shell, no file rights, no web. Now, I stripped the binary, so no debug info and no symbols, and then I searched it for the word Yapf, which is the name of OpenTTD’s pathfinder. And you can see that it still finds full function names like Yap train choose track. So, strip is not enough here. The game links with a flag called RDynamic, which leaves 19,080 exported symbols in the file. I relinked without that flag, and the exports dropped to 55. That’s the

[02:35] file I used for the real test. There’s one more thing worth noting. 11 compiler strings still mention a function called add new node with the track follower types. Real programs leak like this, so I left them in. Also, the first analysis took about 17 minutes in Ghidra, and REA’s default deadline is 330 seconds. It timed out. The readme mentions a setting for that, REA_GhidraStartupTimeoutMS, and I raised it to 45 minutes. The question was simple. How does a

[03:05] train choose its route at a junction, and show evidence for every claim? 52 turns, 19 minutes, 97 cents. What it found, six fields of a path segment and 13 reasons a segment can end, decoded one by one from a string table. I checked all of them against the real source, 13 out of 13 in the right order. It also found the search node, parent, cost estimate, and signal counters, and it said it looks like a best first search. That’s right, it’s A*.

[03:36] But, it did not find the cost formula, and it said so. And there’s one claim it got wrong. It told me the binary has no penalty strings, nothing like real slope. But, they’re right here, real slope penalty curve 90 first red. It was confident, and it was wrong. So, that’s a good reminder, check the negatives too. For run two, I corrected it. I told it those strings exist and gave it the offsets from run one. So, mind you, this one is not blind and I locked the real source, so the agent’s user can’t read it. The permission is denied. I checked.

[04:06] 28 minutes, 84 turns, $2.26. And here’s what it came back with. It found that each setting has a tiny function that returns an offset into one settings object and it mapped all 24 settings to offsets eight by following the name, 14 from the order of the stubs. I checked everyone against the real struct, 24 out of 24. Then the cost, a straight piece of track costs 100, a diagonal piece 71, a 45° turn adds one penalty, and 90° turn adds another. Slope, crossing station, red

[04:38] signals, and a bonus for green signals, and the distance estimate, the smaller of the two distances times 71 plus the difference minus one times 50. That’s exactly the real one. What it did not find are the default values. I’ll come back to that. Now, I wrote a spec only from what the agent found. No game source where the agent didn’t establish something, the spec says gap. Then I built a pathfinder. 10 tests with the costs worked out by hand from the spec. A straight line is 400 for four tiles. The turn south turn east test is

[05:10] 171 + 71 + 200 + 100. They all pass. And this is the page. The train starts here, the station is there, and there’s a red signal on the short route. So, it takes the detour and the total is 1984. If I turn that signal green, the route goes straight and the cost drops to 500 because a green signal gives a bonus. And if I make it a red exit signal, the penalty is 10,000. So, it goes round again. You can change the penalties with these sliders and watch the route change. Let’s go ahead and run the train.

[05:41] I ran two more attempts to get the default values. How big is the slope penalty by default? The first one stopped halfway because my account hit a usage limit. The second one finished 21 minutes 57 cents and it found nothing. It said the registration code has no default in it and the settings object is empty in the file, so they get filled in at runtime. And it refused to guess. That’s the right answer, even if it’s not the one I wanted. So the clone uses the game’s published defaults and the page says that. And three more things I should tell you.

[06:11] The real slow penalty only applies going uphill and mine applies both ways. I didn’t implement signal reservation or platform lengths and I haven’t run my clone against the real game on the same track layout. So those 10 tests check my reading of the spec, not the game. So in this video we have seen how an agent can pull the structure, the cost formula, and 24 settings out of a stripped game file and where it couldn’t. The four agent runs together cost $4.39. If you’re interested, you can go ahead and try REA on a program you build yourself and let me know how

[06:42] it goes. I’ll see you in another one. Check out the next video.