La maggior parte di chi prova a fare reverse engineering di un binario lo apre in un editor esadecimale, scorre per venti minuti e poi molla.
Non sanno quale tool carichi il file. Non sanno quale prompt estragga la logica. Non sanno come trasformare un muro di assembly in qualcosa che possano davvero ricostruire.
Questo corso in 11 step trasformerà Claude Opus 5.5 in una macchina open-source capace di tutto.
Segui il mio Substack per ricevere le ultime alpha sull'AI:
Il reverse engineering non significa craccare. Significa capire qualcosa abbastanza bene da poterlo costruire con le proprie mani.
Il 7 ottobre 2026 Amjad Masad, CEO di Replit, ha pubblicato una sola riga:
https://x.com/amasad/status/2107671204639465961
sotto, uno sviluppatore chiamato @morluto ha risposto con le prove: un set di strumenti che permette agli agenti di pilotare Hopper e Ghidra e di arrivare molto lontano.
Quel progetto è REA, e ha superato le 110.000 stelle su GitHub in pochi giorni.
https://github.com/morluto/rea
Non è hype. La stessa settimana, un progetto open-source chiamato WordCraft ha rilasciato una ricostruzione clean-room di Microsoft e Adobe in puro Rust:
È stato costruito osservando il comportamento di Word e Adobe e leggendo le specifiche pubbliche dei formati di file, senza mai toccarne il codice.
Questo corso ti mostra l'intero percorso, da un binario sigillato a una ricostruzione del genere, con Opus 5.5 che si occupa della lettura.
01. Il motore - come un agente legge un binario
Opus 5.5 non può eseguire un disassembler da solo. Legge testo e scrive testo.
Il reverse engineering con un agente funziona perché c'è un tool tra il modello e il binario: carica il file in un vero motore di disassemblaggio, espone i risultati come funzioni richiamabili e permette al modello di fare domande.
Quel tool è REA, e il motore sotto il cofano è Hopper, Ghidra o IDA.
Il ciclo è semplice e si ripete: il modello chiede a REA di ispezionare il target, REA restituisce i risultati con le prove esatte (indirizzi, byte, pseudocodice, call site), e il modello usa quelle informazioni per fare la domanda successiva o per scrivere e testare una reimplementazione.
Tutto gira in locale sulla tua macchina. Non viene caricato nulla, tranne i dati di cui il modello ha bisogno per ragionare, e ogni conclusione viene etichettata come osservazione, deduzione o dato sconosciuto.
**
02. L'installazione - rea-agents più un disassembler
Il setup registra il server MCP di REA nel tuo agente e installa le istruzioni di workflow corrispondenti.
Basta un comando: ti mostra ogni modifica prima di scrivere qualsiasi cosa e fa il backup di ciò che tocca.
Il disassembler lo scegli tu: Hopper su macOS è la strada più semplice, Ghidra è gratuito e multipiattaforma, IDA se lo possiedi già.
1# 1. Registra REA nel tuo agente (Claude Code, Codex, Cursor, Gemini CLI...)2npx rea-agents setup # mostra le modifiche previste, chiede conferma prima di scrivere34# 2. Un provider per l'analisi approfondita. Hopper è il più fluido su macOS;5# il setup può installarlo previa approvazione. Ghidra e IDA sono "bring-your-own".6# 3. Installa la CLI rea per usarla da terminale e negli script7npm install --global rea-agents8rea --help910# 4. Riavvia il tuo agente, poi verifica che i tool siano attivi11claude12> /mcp13 rea: connected14 open_binary, binary_overview, analyze_function, decompile,15 list_procedures, search, xrefs, trace, inspect_artifact,16 analyze_javascript_application, inspect_managed_artifact ...
I requisiti sono modesti: Node.js 22 o successivo e npm. L'analisi nativa richiede uno dei tre motori; l'ispezione statica di JavaScript e .NET non ne richiede nessuno. Tieni REA aggiornato, perché le release includono fix frequenti.
1# Regole della casa per il reverse engineering ( CLAUDE.MD )23## Autorità4- Analizza solo target di mia proprietà o che sono autorizzato a esaminare. Dichiara la base una volta sola.5- Ogni affermazione è etichettata: osservazione (visto direttamente), deduzione (ricavato logicamente) o sconosciuto.6- Cita le prove: indirizzo, byte, pseudocodice o call site. Nessuna affermazione senza fonte.78## Workflow9- Parti dalla panoramica più piccola possibile, non da un dump completo. Espandi solo se c'è una lacuna concreta.10- Riusa la sessione aperta; non rieseguire mai un'analisi identica.11- Separa i fatti statici dai fatti a runtime. Non dedurre mai l'esecuzione da letture statiche.1213## Ricostruzione14- Costruisci partendo dal COMPORTAMENTO e dalle specifiche pubbliche, mai da codice o asset copiati.15- Tieni un registro degli obblighi: ogni comportamento recuperato richiede un test superato prima di considerarsi "fatto".
Opus 5.5 offre cinque livelli di effort: low, medium, high, xhigh e max. Usali così:
- Medium per ispezionare e navigare
- High per annotare le funzioni ordinarie
- Max per il codice offuscato e per tutto ciò che richiede calcoli pesanti sui puntatori.
L'effort è la singola leva che incide di più sulla qualità in tutto questo corso.
03. Il router - 20 tipi di target, un tool ciascuno
Il primo errore dei principianti è lanciare un disassembler quando il target è un'app Electron il cui JavaScript è lì, bello e pronto.
REA instrada il target verso il tool giusto, e lo stesso dovrebbe fare il tuo primo prompt. Nomina il file, nomina la funzionalità e lascia che sia l'agente a scegliere il punto di ingresso.
1Voglio capire come funziona [FUNZIONALITÀ] in [APP], che si trova in [PERCORSO ASSOLUTO].23Prima dimmi che tipo di target è (nativo, Electron/JS, .NET, Go, APK, WASM)4e scegli il tool REA giusto per aprirlo. Non iniziare ancora l'analisi approfondita.56Poi dammi una mappa in un paragrafo: con cosa è costruita l'app, quanto è grande e7dove cercheresti per prima cosa [FUNZIONALITÀ]. Tieni separate osservazioni, deduzioni e dati sconosciuti,8e cita le prove per qualsiasi cosa affermi.
Puntare REA su un'app Electron restituisce moduli, import e confini IPC in pochi secondi, senza alcun disassembler.
Puntarlo su un Mach-O o un ELF nativo apre un database Hopper e ti dà il percorso nativo, più complesso ma più profondo. Sapere in quale dei due ti trovi ti fa risparmiare ore.
https://x.com/_vmlops/status/2106690704244420687
04. Ricognizione - panoramica, stringhe e grafo delle chiamate
Non aprire ancora nessun codice. Prima chiedi a REA una mappa dell'intero file. Un solo comando ti dice su che tipo di macchina gira, quante funzioni contiene e tutto il testo leggibile sepolto al suo interno.
Quel testo è l'indizio più rapido che hai: indirizzi web, messaggi di errore e nomi delle funzionalità ti dicono cosa fa l'app prima ancora di leggere una singola riga di codice.
1rea.open_binary { path: "/Applications/Target.app/Contents/MacOS/Target" }2rea.binary_overview {}3 arch: arm644 functions: 1,284 identified5 segments: __TEXT __DATA __LINKEDIT6 entry: _main @ 0x1000051c078rea.search { query: "http" } # strings + code refs9 0x10004a2c0 "https://api.target.app/v3/sync"10 0x10004a300 "Authorization: Bearer "11 0x10004a330 "offline cache miss, falling back"1213rea.xrefs { address: "0x100012ab0" } # who calls this?14 147 references -> core config loader, called everywhere
REA conta anche quante volte viene chiamata ogni funzione (questo conteggio si chiama cross-reference, o xref).
Una funzione chiamata 147 volte è il cuore dell'app e merita il massimo sforzo. Una chiamata due volte è un piccolo helper che puoi ignorare finché non diventa rilevante. Parti dall'inizio di quella lista e scendi.
05. Decompilazione - una funzione in pseudocodice
Ora scegli una di quelle funzioni molto attive e trasformala in qualcosa di leggibile. Un decompilatore prende le istruzioni macchina grezze e le riscrive come codice simile al C.
Sembra rozzo: nomi come var_28, logica aggrovigliata, cast ovunque. Ma puoi leggerlo, e ad Opus 5.5 basta che sia leggibile.
Eseguilo da riga di comando per salvare il risultato, oppure direttamente da una chat.
1# Decompila una funzione per indirizzo, in JSON da pipare o salvare2rea decompile /Applications/Target.app/.../Target 0x100012ab0 \3 --provider hopper --json > fn_config_loader.json45# Oppure cerca una funzione per nome e segui i riferimenti6rea function /path/to/Target parseConfig --provider hopper --json7rea xrefs /path/to/Target 0x100012ab0 --provider hopper --json8rea trace /path/to/Target "sync" --provider hopper --json
1// 0x100012ab0 xrefs: 1472void sub_100012ab0(void* arg0) {3 void* var_20 = objc_msgSend(cls_NSJSONSerialization,4 sel_JSONObjectWithData_options_error, arg0, 0x0, 0x0);5 if (var_20 != 0x0) {6 void* var_28 = objc_msgSend(var_20, sel_objectForKey, @"endpoints");7 void* var_30 = objc_msgSend(var_20, sel_objectForKey, @"auth_mode");8 void* var_38 = objc_msgSend(var_20, sel_objectForKey, @"retry_count");9 objc_msgSend(g_sharedConfig, sel_setEndpoints, var_28);10 objc_msgSend(g_sharedConfig, sel_setAuthMode, var_30);11 objc_msgSend(g_sharedConfig, sel_setRetryCount,12 objc_msgSend(var_38, sel_intValue));13 }14}
Lo showcase ufficiale di REA segue una chiamata audio nel vecchio gioco DX-Ball fino all'helper che decide il bilanciamento audio sinistra-destra, per poi trasformare lo pseudocodice incompleto in C.
Il risultato supera tutti i 3.205 test case originali e riproduce ognuno dei 63 byte compilati.
Il walkthrough completo è su rea.tools/showcase.
06. Annotazione - fai dare un nome a ogni variabile da Opus
Quel codice grezzo è solo metà del lavoro. Ora passalo a Opus 5.5 e chiedigli di spiegarlo e ripulirlo.
Rinomina le variabili criptiche con nomi reali, spiega in una frase a cosa serve la funzione, individua il pattern che segue e segnala persino i bug lasciati nell'app originale.
Incolla questo prompt con Claude:
1Ecco lo pseudocodice decompilato di una funzione con 147 cross-reference.23Per questa funzione:41. Rinomina ogni variabile con un nome significativo basato sul suo utilizzo.52. Spiegane lo scopo in una frase.63. Elenca le strutture dati che legge e scrive.74. Nomina il pattern (singleton, factory, state machine, observer...).85. Riscrivila in Swift pulito e idiomatico (o nel linguaggio suggerito dalle9 calling convention), con commenti di documentazione.106. Segnala eventuali mancanze nella gestione degli errori, validazione degli input o controlli di sicurezza.1112Ragiona a effort xhigh prima di rispondere: analizza cosa rappresenta ogni13valore prima di assegnare i nomi. Segna tutto ciò di cui non sei sicuro.1415[incolla lo pseudocodice]
La decompilazione ti dice cosa fa il codice. Opus 5.5 ti dice perché, e ti dà i nomi per ricostruirlo.
https://x.com/0x0SojalSec/status/2108389060192706674
https://x.com/0x0SojalSec/status/2108031166502896035
Non tutti i target richiedono un disassembler. Lo showcase Notion di REA trova la funzionalità degli appunti nel JavaScript dell'app, la segue attraverso i layer di Electron fino al processo principale e mostra esattamente come costruisce gli appunti formattati: un trace completo senza una riga di assembly. Vedi
07. Offuscamento - il benchmark Tigress
Alcune app sono costruite proprio per resistere a quello che stai facendo. Il loro codice è mescolato di proposito: la logica è rimescolata, il testo è cifrato e vengono aggiunti rami finti per farti perdere tempo.
Questo si chiama offuscamento, ed è l'unico punto in cui anche il modello migliore va in difficoltà. Elastic Security Labs lo ha misurato, puntando Claude Opus sullo scrambler Tigress su 20 task. Tieni a mente questi numeri.
Da quei numeri emergono due lezioni pratiche.
- Primo: un tentativo fallito costa circa il doppio di uno riuscito, perché il modello continua a provarci sempre più intensamente prima di arrendersi. Quindi imposta un limite di spesa per funzione e fermati presto.
- Secondo: elimina la spazzatura dal codice decompilato prima di inviarlo (un tool gratuito chiamato Caveman ne rimuove circa il 75%), così il modello concentrerà la sua attenzione sulla logica reale, non sul riempitivo.
I cinque trucchi che incontrerai davvero, e come si presentano quando apri il codice:
1Questa funzione sembra offuscata. Lavora a effort max.231. Identifica le tecniche presenti (control-flow flattening, predicati opachi,4 codice morto, cifratura delle stringhe, function splitting) e indica dove ciascuna compare5 in questo specifico codice.62. Risolvile: rimuovi i rami morti, valuta i predicati opachi, srotola il7 dispatch, decifra le stringhe inline se la chiave è recuperabile.83. Mostra la funzione pulita che rimane.94. Valuta la tua sicurezza da 1 a 10. Sotto il 6, dimmi esattamente quali parti sono incerte10 e quale contesto adiacente le chiarirebbe. Non tirare a indovinare in silenzio.1112[incolla lo pseudocodice offuscato]
08. Lo sciame - un controller che gestisce i worker
Una singola chat non riesce a leggere bene 500 funzioni. Dimentica ciò che ha visto, chiama la stessa cosa con tre nomi diversi e inizia a contraddirsi.
La soluzione è un piccolo team: una chat controller che distribuisce il lavoro e diverse chat worker che prendono in carico una funzione ciascuna.
Il controller mantiene la visione d'insieme e ricuce i pezzi.
Non devi costruire nulla di speciale per questo: i due prompt qui sotto sono l'intera configurazione.
1Sei un controller di reverse engineering. La mappa delle funzioni è in functions.json2(indirizzo, nome, dimensione, xref_count).341. 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 una funzione tu stesso.63. Inietta le struct già risolte nel brief di ogni worker, così i nomi restano coerenti.74. Quando un worker restituisce una sicurezza inferiore a 6, metti in coda un secondo passaggio con il contesto8 dei vicini già risolti.95. Traccia il consumo cumulativo di token e segnalalo dopo ogni cluster.
1Sei un worker. Ricevi una funzione decompilata e le struct risolte finora.2Restituisci esattamente: indirizzo, scopo, sicurezza (1-10), structs_used, structs_new,3clean_source, flag. Riusa i nomi delle struct esistenti; non inventare mai un secondo nome per4una struct che il controller ti ha già fornito. Solo una funzione. Fermati quando hai finito.
https://x.com/victor_explore/status/2109466356454510612
09. Clean room - quattro regole per restare nella legalità
Una ricostruzione clean-room significa copiare ciò che fa l'app, 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.
Quattro regole ti tengono al sicuro, e il team di WordCraft le verifica tutte e quattro automaticamente a ogni build.
- Osserva, non copiare. Esegui il target in black-box, guarda cosa fa, fai screenshot solo della sua finestra. Non leggere, disassemblare o incollare mai il suo codice. Non copiare testi oltre ai semplici nomi delle funzionalità.
- Specifiche, non sorgenti. I formati di file derivano da standard pubblici (OOXML è ECMA-376 / ISO 29500, più le specifiche RTF e ODF pubblicate), mai dalla lettura del parser di un concorrente o da codice GPL/LGPL.
- Solo asset originali. Ogni icona, font, template e suono è generato via codice, di pubblico dominio o con licenza aperta, con una riga in un file di attribuzione. Altrimenti un controllo CI fa fallire la build.
- Separa i due lavori. Un agente recupera il comportamento e scrive una specifica. Un contesto diverso implementa partendo solo dalla specifica, senza mai guardare l'analisi originale. Questa separazione è il confine della clean room.
1Dall'analisi completata, scrivi una specifica clean-room per una reimplementazione.23Descrivi SOLO il COMPORTAMENTO. Includi: ogni interfaccia pubblica, il modello dati, ogni4funzionalità visibile all'utente come requisito testabile, i formati di file letti e scritti5(in base al comportamento osservato e alle specifiche pubbliche) e la gestione degli errori.67NON includere: indirizzi o offset, nomi di variabili dal decompilato, assembly,8o qualsiasi cosa copiata dall'originale. Uno sviluppatore che non ha mai visto il binario deve poter9implementare una versione compatibile basandosi solo su questo documento.1011Produci markdown con le sezioni: Architettura, Modello Dati, API Pubblica, Formati File,12Casi di Test.
Lavorare da una descrizione non è solo una copertura legale. Ti permette di fare le scelte giuste per il tuo linguaggio e le tue esigenze, invece di ereditare decisioni prese dall'autore originale decenni fa.
WordCraft è più veloce di Word in alcuni punti proprio perché non ne ha copiato le viscere.
10. Creare App - dodici tool pro, un solo metodo
WordCraft non è un caso isolato. È un'app in uno scaffale di dodici realizzate dal team ArtCraft, ognuna una ricostruzione clean-room di un tool per cui paghi già, tutte scritte da zero in Rust e rilasciate gratis e open source su GitHub.
Il loro motto è "Dodici app. Un'unica arte", e quell'arte è il metodo dello step 9: osserva l'originale, leggi le specifiche pubbliche, costruisci una versione nuova basandoti solo sul comportamento.
Il vantaggio di quel metodo condiviso è lo stesso ovunque. Niente Electron: ogni app è nativa su macOS, Windows e Linux, e tutte tranne FilmCraft girano anche in una scheda del browser tramite WebAssembly.
E poiché ogni azione al loro interno è un comando con un nome, tutte e dodici possono essere pilotate immediatamente da un agente AI.
Ogni app Craft è costruita allo stesso modo, e vale la pena copiare questa struttura. Ognuna è organizzata a strati, e ogni strato usa solo quello sottostante, dalle misurazioni di base in basso fino alla finestra a schermo in alto.
Ecco gli strati di WordCraft:
E ogni azione è semplicemente un comando nominato, quindi un clic umano, una scorciatoia da tastiera e un agente AI attivano esattamente la stessa cosa. È questo che rende ognuna di esse pilotabile da un agente.
1pilotare WordCraft tramite MCP23# Automazione documentale headless4claude mcp add wordcraft -- wordcraft-cli mcp56# Oppure pilota l'app desktop in esecuzione7wordcraft --control 7981 &8claude mcp add wordcraft-app -- wordcraft-cli mcp --connect 127.0.0.1:7981910# Tool: list_commands, execute, batch, type_text, select_text,11# inspect_document, render_page, save_document (+ screenshot/click/key live)12> Apri report.docx, imposta ogni titolo a 14pt grassetto, esporta in PDF13 ✓ select.all-headings -> 12 selezionati14 ✓ format.font-size 14 · format.bold15 ✓ export report.pdf (testo selezionabile, segnalibri mantenuti)
https://x.com/yuhasbeentaken/status/2109235513102057828
11. Verifica e rilascio - dimostra la parità, esponi MCP
Non hai mai avuto il codice sorgente dell'originale, quindi non puoi confrontarlo riga per riga.
Confronti invece il comportamento: dai gli stessi input sia all'originale sia alla tua ricostruzione e verifichi che producano lo stesso output.
1Costruisci un test harness comportamentale che confronti il binario originale e la mia ricostruzione.23Genera 50 input: 30 normali, 10 edge (vuoto, dimensione massima, unicode, caratteri speciali),410 di errore (malformati, campi mancanti, corrotti). Passali entrambi. Confronta l'output5byte per byte dove possibile, semanticamente altrimenti. Riporta il tasso di corrispondenza, una lista6delle divergenze e una gravità per ciascuna (estetica / comportamentale / critica). Salva in report.md.
Questa è anche la prova più convincente che puoi mostrare a chiunque (lo slot RE in cima all'articolo).
Poi rilascia la tua ricostruzione come hanno fatto REA e WordCraft: come server MCP, così l'agente della prossima persona potrà pilotarla esattamente come tu hai pilotato REA.
Dai a ogni funzione un nome e una descrizione chiari, avvolgila in un semplice tool da riga di comando e rendila installabile con una sola riga.
https://x.com/0xMovez/status/2108884063515746410
E testa man mano, non alla fine, perché un errore scoperto dopo averci costruito sopra tre strati è molto più costoso da correggere.
Sei errori che ti bruciano un weekend
- Aprire un disassembler su un'app Electron. Se il JavaScript è lì davanti a te, instrada verso analyze_javascript_application e salta del tutto il percorso nativo.
- Fare il dump di tutto prima di aver letto qualcosa. Chiedi prima un riepilogo a REA. Tirare giù l'intera app in un colpo solo seppellisce la logica reale nel rumore e fa lievitare la bolletta.
- Leggere le funzioni nell'ordine del file. Ordina per numero di cross-reference. La funzione con 147 xref è l'architettura; l'helper con 2 xref può aspettare.
- Accanirsi sull'offuscamento di livello 3. Il benchmark risolve lo 0% dei multi-layer. Fissa un budget, metti da parte il contesto dei vicini, tornaci dopo.
- Lasciare che il modello copi codice nella tua ricostruzione. Questo rompe la clean room. Prima le specifiche in un contesto, poi l'implementazione dalle specifiche in un altro.
- Rilasciare senza un report di parità. "Credo che corrisponda" non è una prova. 50 test comportamentali e un tasso di corrispondenza lo sono.
Conclusione:
Installa REA. Leggi il binario. Ricostruiscilo come fosse tuo.
Instrada il target, mappa la sua superficie, decompila le funzioni calde, lascia che Opus 5.5 dia un nome a tutto, rompi l'offuscamento che vale la pena rompere, scala con uno sciame, poi scrivi specifiche pulite e rilascia la ricostruzione via MCP.
Undici step. Un modello. Zero codice copiato.
