Come trasformare Opus 5.5 in una macchina per il reverse engineering con 8 passaggi (corso completo)

L'8 ottobre 2026, una repository di cui nessuno aveva sentito parlare tre mesi prima è arrivata al primo posto tra i trending di GitHub.

Si chiama REA, Reverse Engineer Anything, e fornisce al tuo agente un vero disassemblatore.

**Salva questa pagina nei preferiti: se vuoi la versione estesa, il corso completo in 20 lezioni su questo argomento è online su**

reacourse.xyz

Ti porta da un terminale vuoto a una ricostruzione che supera i propri test di parità, con ogni comando e prompt scritti per esteso. INIZIA DA QUI.

Quella settimana la reazione è stata identica ovunque.

Matthew Berman l'ha riassunta in tre parole, e 3,6 milioni di persone l'hanno vista.

https://x.com/MatthewBerman/status/2108245653843509415

REA è un server MCP open source con CLI che si collega a Claude Code, Codex, Cursor e Gemini CLI.

Licenza MIT, creato da morluto, prima release il 12 luglio 2026 e, tre mesi dopo, oltre 100.000 stelle su GitHub.

Tutto gira in locale e ogni conclusione viene etichettata come osservazione, deduzione o incognita, con l'indirizzo o il punto di chiamata che la supporta.

Questo è l'intero percorso, in otto passaggi, da un binario sigillato a una ricostruzione di tua proprietà.

Prima dei passaggi: cosa hanno già rilasciato le persone con questo strumento

Lo strumento non è la vera storia, lo è ciò che è stato pubblicato in quattro settimane.

ArtCraft ha ricostruito sette app Adobe come alternative gratuite e open source, per poi puntare su Office con WordCraft, GridCraft e DeckCraft.

Dodici app finora, tutte scritte da zero in Rust, native su tre piattaforme e, tranne una, eseguibili anche in una scheda del browser tramite WebAssembly.

Sul fronte gaming, le prove sono ancora più precise:

• Super Mario Sunshine ha ottenuto un porting nativo per PC: circa 365 ore di lavoro dell'agente e 17,3 miliardi di token, usando insieme Claude e Codex
• Un gioco Touhou ricostruito con gli agenti sul blog ufficiale di REA: 697 funzioni, 696 corrispondenze esatte, giocabile in circa 12 giorni
• L'autenticatore Aegis (3.077 classi) smontato e ricostruito, con tutti i 133 casi di test superati
• La funzione di panning audio di DX-Ball ricostruita in C, superando 3.205 casi di test x86 originali e riproducendo tutti i 63 byte compilati

Nota bene cosa non contiene questa lista.

Nessuno ha craccato un controllo di licenza, nessuno ha pubblicato il codice sorgente di qualcun altro.

Ognuno di questi risultati è un comportamento recuperato, documentato e ricostruito in codice nuovo.

01. Analizza il target prima di aprire qualsiasi cosa

Il motivo per cui si è diffuso così tanto non è che legge bene una sola cosa. Legge quasi tutto e mostra le prove di ogni affermazione che fa.

https://x.com/RoundtableSpace/status/2109165852578992582

Quella lista è anche la prima decisione che prendi. Il modo più comune per buttare un pomeriggio è cercare un disassemblatore quando il target è un'app Electron il cui JavaScript è già lì in chiaro.

Punta REA su Electron e ottieni moduli, importazioni e confini IPC in pochi secondi senza alcun motore, mentre un Mach-O o ELF nativo apre un database Hopper, che è il percorso più profondo ma anche più lento.

Capire in quale scenario ti trovi ti fa risparmiare ore, quindi rendilo il compito del tuo primo prompt.

1Voglio capire come funziona [FUNZIONALITÀ] in [APP], che si trova in [PERCORSO ASSOLUTO].
2    Prima dimmi che tipo di target è (nativo, Electron/JS, .NET, Go, APK, WASM)
3    e scegli lo strumento REA giusto per aprirlo. Non iniziare ancora l'analisi approfondita.
4    Poi descrivilo in un paragrafo: con cosa è costruito, quanto è grande, dove
5    cercheresti prima [FUNZIONALITÀ]. Tieni separate osservazioni, deduzioni e incognite.

La parte che quasi nessuno menziona: molti giochi Unity distribuiscono la loro logica in .NET, e REA legge .NET senza motori aggiuntivi.

È proprio per questo che un gioco acquistato su Steam passa da binario a C# modificabile in meno di mezz'ora.

E ogni app Electron sul tuo computer è leggibile in questo momento, senza nemmeno avviarla:

1# dove si trova il JavaScript
2macOS:   /Applications/<App>.app/Contents/Resources/app.asar
3Windows: C:\Users\<tu>\AppData\Local\Programs\<App>\resources\app.asar
4    npx -y rea-agents@latest analyze-javascript-application /percorso/assoluto/dell/app --json

02. Installalo in cinque minuti, poi aggiungi un motore

Ciò che fa funzionare tutto questo non è un prompt geniale. È un vero motore di disassemblaggio collegato all'agente, esattamente come lo ha descritto uno sviluppatore.

https://x.com/techNmak/status/2108431092462338178

Il setup registra il server MCP con il tuo agente e installa la skill di workflow corrispondente.

Mostra ogni modifica prima di scrivere qualsiasi cosa e fa il backup di ciò che tocca.

node -v # Node 22.19+, 24.11+ o 26+. Le versioni 23 e 25 non sono supportate

1npx rea-agents@latest setup          # registra il server MCP, chiede conferma prima di scrivere
2npm install --global rea-agents      # il comando breve rea, per sempre
3rea --help
4# riavvia l'agente, poi verifica. doctor controlla soltanto, non modifica mai nulla
5npx -y rea-agents@latest doctor --client claude_code --json

Il riavvio conta più di quanto sembri: una sessione del terminale deve essere avviata da zero e le app desktop richiedono un'uscita completa, perché chiudere la finestra non basta.

Poi aggiungi un motore solo per ciò che vuoi effettivamente leggere:

C'è un file che vale la pena scrivere prima del tuo primo vero target: le regole della casa in claude-md.

Analizza solo ciò che possiedi, etichetta ogni affermazione come osservazione, deduzione o incognita, cita l'indirizzo che la supporta e non considerare mai concluso un comportamento recuperato senza un test superato.

1# programmi e giochi nativi: Ghidra 12.1.x e JDK 21 o successivo
2    export GHIDRA_INSTALL_DIR=/percorso/assoluto/per/ghidra_12.1.4_PUBLIC
3    export JAVA_HOME=/percorso/assoluto/per/jdk-21
4    npx -y rea-agents@latest doctor --provider ghidra --json
5
6    # app Android: JDK 17+ e jadx-headless-mcp 0.7.1
7    export REA_JADX_MCP_JAR=/percorso/assoluto/jadx-headless-mcp-0.7.1-all.jar
8    rea inspect-android-package /percorso/App.apk
9
10    # bytecode degli smart contract, per ora solo Linux x64
11    rea inspect-evm-interface ./runtime.hex hex --json

03. Ricognizione: la mappa viene prima del codice

Non aprire ancora nessuna funzione.

Un solo comando ti dice su quale macchina gira il binario, quante funzioni contiene e tutto il testo leggibile nascosto al suo interno.

Quel testo è l'indizio più veloce che otterrai in tutta la giornata: endpoint, stringhe di errore e nomi delle funzionalità descrivono l'app prima ancora che tu ne legga la logica.

1rea.open_binary        { path: "/Applications/Target.app/Contents/MacOS/Target" }
2rea.binary_overview    {}
3  arch:        arm64
4  functions:   1.284 identificate
5  entry:       _main @ 0x1000051c0
6
7rea.search             { query: "http" }
8  0x10004a2c0  "https://api.target.app/v3/sync"
9  0x10004a300  "Authorization: Bearer "
10
11rea.xrefs              { address: "0x100012ab0" }
12  147 riferimenti  ->  loader di configurazione principale, richiamato ovunque

REA conta quante volte viene chiamata ogni funzione, e quel conteggio è il numero di riferimenti incrociati.

Una funzione chiamata 147 volte rappresenta l'architettura dell'app; una chiamata due volte è un helper che può aspettare.

Ordina in base a quel numero e procedi dall'alto verso il basso, mai nell'ordine del file, perché seguire l'ordine del file è il modo in cui si perde un intero weekend dentro un binario che conteneva solo quattro funzioni interessanti.

04. Decompila una funzione, poi fai rinominare tutto a Opus

Un decompilatore trasforma le istruzioni macchina grezze in qualcosa di simile al C.

Il risultato è rozzo: nomi come var_28, cast ovunque, rami aggrovigliati. Ma va benissimo, perché al modello serve solo che sia leggibile.

1# una funzione per indirizzo, in formato JSON salvabile e riutilizzabile
2rea decompile /percorso/del/Target 0x100012ab0 --provider hopper --json > fn_config.json
3
4# oppure trovala per nome e segui i suoi riferimenti
5rea function /percorso/del/Target parseConfig --provider hopper --json
6rea xrefs    /percorso/del/Target 0x100012ab0 --provider hopper --json

Poi passa quell'output a Opus 5.5 e fagli fare la parte che il disassemblatore non può gestire:

1Ecco lo pseudocodice decompilato di una funzione con 147 riferimenti incrociati.
2
31. Rinomina ogni variabile in base a come viene usata e spiegane lo scopo in una frase.
42. Elenca le strutture dati che legge e scrive, e dai un nome al pattern che segue.
53. Riscrivila come codice pulito e idiomatico nel linguaggio suggerito dalle convenzioni di chiamata.
64. Segnala eventuali gestioni degli errori, validazioni degli input o controlli di sicurezza mancanti.
7
8Ragiona con livello di impegno xhigh prima di rispondere. Contrassegna tutto ciò di cui non sei sicuro.

Opus 5.5 offre cinque livelli di impegno: low, medium, high, xhigh e max.

Medium ispeziona e naviga, high annota le funzioni ordinarie, max serve per il codice offuscato e l'aritmetica pesante dei puntatori.

L'impegno è la manopola qualitativa più importante in questa pipeline, e la maggior parte delle persone lo lascia sul valore predefinito per poi dare la colpa al modello.

La decompilazione ti dice cosa fa il codice, il modello ti spiega perché e ti dà i nomi per ricostruirlo.

05. Offuscamento: rompi ciò che vale la pena rompere, metti a budget il resto

Alcune app sono costruite per resistere esattamente a quello che stai facendo: logica mescolata, stringhe crittografate, rami falsi aggiunti solo per sprecare la tua attenzione.

Questo è l'unico punto in cui anche il modello migliore fa fatica, e ci sono numeri precisi a dimostrarlo.

Elastic Security Labs ha puntato Claude Opus sullo scrambler Tigress su 20 task, e ne emergono subito due lezioni.

Un tentativo fallito costa circa il doppio di uno riuscito, perché il modello continua a insistere prima di arrendersi; inoltre l'offuscamento multi-livello ha restituito zero successi, quindi ostinarsi è il modo più costoso per non imparare nulla.

La regola pratica è avere un budget per funzione, non per sessione.

Elimina prima il rumore di fondo: uno strumento gratuito chiamato Caveman rimuove circa il 75% della spazzatura decompilata, permettendo al modello di concentrare l'attenzione sulla logica reale.

1Questa funzione sembra offuscata. Lavora con impegno max.
2
31. Identifica le tecniche presenti (appiattimento del flusso di controllo, predicati opachi,
4   codice morto, crittografia delle stringhe, suddivisione delle funzioni) e indica ciascuna qui.
52. Risolvile: rimuovi i rami morti, valuta i predicati opachi, ripristina il dispatch,
6   decifra le stringhe inline se la chiave è recuperabile. Mostra cosa rimane.
73. Valuta la confidenza da 1 a 10. Sotto il 6, indica le parti incerte e quale contesto
8   le chiarirebbe. Non tirare a indovinare in silenzio.

06. Lo sciame: un controller, molti worker

Una singola chat non riesce a leggere bene 500 funzioni.

Dimentica ciò che ha visto quaranta funzioni prima, nomina la stessa struct in tre modi diversi e inizia silenziosamente a contraddirsi.

La soluzione non è aggiungere contesto, ma dividere i ruoli: un controller che assegna il lavoro e dei worker che prendono ciascuno una funzione e si fermano.

1Sei un controller di reverse engineering. La mappa delle funzioni è in functions.json
2(indirizzo, nome, dimensione, xref_count).
3
41. Raggruppa le funzioni per vicinanza nel grafo delle chiamate; ordina i cluster per xref count.
52. Assegna ogni cluster a un worker. Non analizzare mai direttamente una funzione.
63. Inietta le struct già risolte in ogni brief affinché i nomi restino coerenti.
74. Una confidenza inferiore a 6 richiede un secondo passaggio con il contesto dei vicini risolti.
85. Monitora il consumo cumulativo di token e segnalalo dopo ogni cluster.
9
10Sei un worker. Ricevi una funzione decompilata e le struct risolte finora.
11Restituisci esattamente: indirizzo, scopo, confidenza (1-10), structs_used, structs_new,
12clean_source, flag. Riutilizza i nomi delle struct esistenti, non inventare mai un secondo nome per
13una struct che il controller ti ha già fornito. Solo una funzione. Fermati quando hai finito.

REA include anche workflow guidati integrati nel server MCP che quasi nessuno apre:

• - investigate_feature - traccia una funzionalità dalla scoperta alle funzioni esatte
• - compare_application_versions - confronta due release e vedi cosa è cambiato davvero
• - verify_reconstruction - verifica la tua ricostruzione rispetto alle prove salvate
• - audit_residual_unknowns - elenca ciò che non è ancora dimostrato

07. Clean room: il muro tra due contesti è il prodotto

Una ricostruzione clean room significa copiare ciò che l'app fa, mai il codice al suo interno.

Se lo fai bene, ciò che rilasci è completamente tuo; se sbagli, ti porti dietro il copyright di qualcun altro nella tua repository.

È un metodo vecchio di 40 anni, non un'invenzione del 2026.

Nei primi anni '80 Compaq ricostruì il BIOS IBM in questo modo spendendo circa 1 milione di dollari, ed è l'unica ragione per cui esistono i PC di altre marche.

Nel 1992 il tribunale nel caso Sega contro Accolade stabilì che smontare il codice può rientrare nel fair use quando è l'unico modo per capirne il funzionamento, e nel 2000 Sony perse 3-0 in Sony contro Connectix perché l'emulatore finale non conteneva alcuna riga di codice Sony.

Anche l'altro lato del confine è altrettanto chiaro: nel 2011 George Hotz patteggiò con Sony e accettò di fermarsi dopo che la root key della PS3 era diventata pubblica.

Quattro regole ti mantengono dalla parte giusta, e il team di ArtCraft le verifica tutte e quattro automaticamente a ogni build:

• - Osserva, non copiare mai. Esegui il target in black-box, fai screenshot solo della sua finestra, non incollare mai il suo codice nel tuo progetto
• - Specifiche, non sorgenti. I formati dei file derivano da standard pubblici (OOXML è ECMA-376 / ISO 29500, oltre alle specifiche pubblicate RTF e ODF), mai dalla lettura del parser di un concorrente
• - Solo asset originali. Ogni icona, font, template e suono è generato via codice, di pubblico dominio o con licenza aperta, con una riga dedicata in un file di attribuzione
• - Separa i due compiti. Un agente recupera il comportamento e scrive le specifiche, un contesto diverso implementa basandosi esclusivamente su quelle specifiche

L'ultima regola è quella che le persone saltano, ed è il vero confine.

Il tuo agente investigativo è contaminato per definizione, perché ha letto il codice decompilato, mentre il tuo agente costruttore non deve esserlo.

1Partendo dall'analisi completata, scrivi una specifica clean room per una reimplementazione.
2
3Descrivi SOLO IL COMPORTAMENTO: ogni interfaccia pubblica, il modello dati, ogni funzionalità
4visibile all'utente come requisito testabile, i formati di file letti e scritti, la gestione degli errori.
5
6NON includere indirizzi, offset, nomi di variabili decompilate, assembly o qualsiasi cosa
7copiata dall'originale. Uno sviluppatore che non ha mai visto il binario deve poter
8implementare una versione compatibile basandosi unicamente su questo documento.
9
10Sezioni: Architettura, Modello Dati, API Pubbliche, Formati File, Casi di Test.

Lavorare partendo da una descrizione non è solo una copertura legale.

Ti permette di fare la scelta giusta per il tuo linguaggio invece di ereditare decisioni prese da qualcuno vent'anni fa, ed è per questo che WordCraft in alcuni punti è più veloce di Word.

08. Verifica la parità, poi rilascia tramite MCP

Non hai mai avuto il codice sorgente originale, quindi non puoi fare un diff riga per riga.

Confronti il comportamento: stessi input in entrambe le build, stessi output in uscita.

1Costruisci un test harness comportamentale che confronti il binario originale e la mia ricostruzione.
2
3Genera 50 input: 30 normali, 10 limite (vuoti, dimensione massima, unicode), 10 di errore
4(malformati, corrotti). Passali entrambi attraverso le due versioni, confrontando byte per byte dove possibile
5e semanticamente negli altri casi. Riporta il tasso di corrispondenza, le divergenze e un livello di gravità per ciascuna
6(cosmetica / comportamentale / critica). Salva in report.md.

"Credo che corrisponda" non è una prova, un tasso di corrispondenza sì, e quel report è la cosa più convincente che puoi mettere in cima a un post di rilascio.

Poi rilascia la ricostruzione come hanno fatto REA e le app Craft, ovvero come server MCP, così l'agente della prossima persona potrà pilotare il tuo strumento esattamente come tu hai pilotato REA.

Dai a ogni funzione un nome chiaro e un'installazione in una riga, e ogni azione diventerà un comando nominato attivabile allo stesso modo con un clic, una scorciatoia o un agente.

1claude mcp add wordcraft -- wordcraft-cli mcp
2
3> Apri report.docx, imposta tutti i titoli a 14pt grassetto, esporta in PDF
4  ok  select.all-headings -> 12 selezionati
5  ok  format.font-size 14 . format.bold
6  ok  export report.pdf (testo selezionabile, segnalibri mantenuti)

I limiti e i cinque errori che ti fanno sprecare un weekend

REA non può toccare il server, perché legge ciò che si trova sul tuo computer e il codice in esecuzione sui server di un'azienda non ti è mai stato distribuito.

Il codice decompilato è una ricostruzione, non il sorgente originale, ed è l'intera ragione per cui esiste il passaggio 08.

I binari C++ strippati restano molto più difficili dei giochi Unity in .NET, e i motori commerciali richiedono comunque licenze reali.

• - Aprire un disassemblatore su un'app Electron quando il JavaScript è già lì in chiaro
• - Scaricare l'intero binario prima di leggerne un riepilogo, seppellendo la logica e facendo lievitare i costi
• - Leggere le funzioni nell'ordine del file invece che per numero di riferimenti incrociati
• - Lasciare che il modello copi codice nella tua ricostruzione, distruggendo la clean room con un solo incolla
• - Rilasciare senza un report di parità

La verità sul lato legale, dato che metà di X ha passato una settimana a gridare alla pirateria: leggere un'app sul proprio computer è studio, ricostruire una funzionalità dal suo comportamento è il modo in cui l'industria lavora dagli anni '80, mentre copiare codice o craccare funzioni a pagamento è ciò che ti porta in tribunale.

Studia l'originale, rilascia il tuo.

Ognuno di questi otto passaggi ha una lezione dedicata su

reacourse.xyz , con i prompt esatti, le modalità di fallimento e i punti in cui questo approccio smette di funzionare.

Un tempo closed source significava che non l'avresti mai saputo.

Oggi significa: mostrami le prove.

La maggior parte delle persone continuerà a pagare un abbonamento mensile per una funzionalità che potrebbe capire in un pomeriggio e ricostruire in un weekend.

I pochi che impareranno a leggere il software costruiranno qualsiasi cosa desiderino.

Seguimi e iscriviti al mio canale Telegram:

https://t.me/+75nMf005jRpjMDU1