KRAKEN

Scomponi un programma e comprendilo, con un aiuto concreto. KRAKEN è un banco di lavoro open-source per il reverse engineering basato sul decompilatore di Ghidra, con un motore nativo senza Java e un motore Ghidra completo opzionale. Tu, i tuoi script e gli agenti AI lavorate tutti sullo stesso progetto tramite un unico insieme di comandi, e ogni modifica è registrata, attribuita e annullabile. Non devi sapere il reverse engineering per iniziare: l'app spiega i termini man mano e il tutorial ti guida attraverso una prima sessione. L'obiettivo a lungo termine è la riscrittura in Rust dei binari, funzione per funzione, verificata rispetto all'originale.

Un vero progetto con motore nativo: stripped_calc-O2-stripped da questo repository, dopo che alcune funzioni sono state nominate.

Cosa fa

Analizza

• Trova le funzioni e le decompila in codice simile al C con il decompilatore di Ghidra: tramite il motore nativo (senza Java; ELF e Windows PE, x86 e x86-64) o il motore Ghidra opzionale (ELF, PE e Mach-O, molti processori).
• Listing, hex, grafo di controllo del flusso, riferimenti incrociati, stringhe, import ed export, mappa della memoria.
• Rinomina funzioni, imposta tipi e commenti. Cerca, filtra e salta tra le viste.

Applica patch

• Modifica i byte di un programma: digita una nuova istruzione e KRAKEN la assembla, oppure modifica il C decompilato e lascia che l'assistente individui la più piccola modifica al codice macchina.
• Esegui il programma originale e quello modificato fianco a fianco in un emulatore sandboxed prima che qualsiasi cosa venga scritta, poi esporta una copia modificata. Il file originale non viene mai toccato.
• Ogni patch è una modifica nella cronologia, quindi le patch di un assistente possono essere revisionate e annullate come qualsiasi altra cosa.

AI

• Assistente integrato: spiega una funzione, un primo sguardo guidato a un programma, suggerimenti di nomi che revisioni prima che qualsiasi cosa cambi, e un glossario offline.
• Funziona con un modello sul tuo computer (Ollama, LM Studio, llama.cpp, o uno che KRAKEN esegue per te) o con un provider cloud.
• Gli agenti da terminale (Claude Code, Codex, Gemini CLI) possono essere eseguiti all'interno dell'app o connettersi dall'esterno tramite MCP.

Automatizza

• Un unico registro di comandi alimenta la CLI, il server MCP, la GUI e gli agenti, così non possono divergere.
• Output --json per gli script, un modulo Python e un daemon in background che mantiene i progetti caldi.
• Ogni modifica è in un log con il suo autore, con undo per singola modifica e per singola esecuzione dell'agente.

Riscrivi

• Traduci una funzione alla volta in Rust, esegui l'originale sotto emulazione e il lato Rust fianco a fianco, e vedi l'input più piccolo in cui divergono.
• Pianifica l'ordine (prima le funzioni chiamate), accetta tu stesso le funzioni verificate, esporta un workspace Cargo.

Stato

KRAKEN è pre-alpha (0.1a). Aspettati spigoli e modifiche incompatibili.

	Linux x86_64	macOS (Apple silicon)	Windows x86_64
CLI, server MCP, GUI	Funziona	Compila, sperimentale	Compila, sperimentale
Motore nativo, senza Java (kraken setup --native)	Funziona (ELF e PE)	Non ancora	Non ancora
Analisi con Ghidra (kraken setup)	Funziona	Non ancora	Non ancora
Sandbox attorno a Ghidra	Landlock	Non ancora	Non ancora
Modelli locali	Funziona	Compila	Compila
Pipeline di riscrittura	Funziona (richiede Landlock e un modello)	Rifiuta di eseguire	Rifiuta di eseguire

"Compila" significa che il codice viene compilato ed è verificato in CI, non che l'intero prodotto sia stato collaudato lì. Linux è la piattaforma da usare oggi.

Installazione

Linux x86_64 (nessun Java necessario: il motore nativo e i suoi file di processore sono nella release):

curl --proto '=https' --tlsv1.2 -fsSL https://raw.githubusercontent.com/Adam-AtlasSoftware/kraken/main/scripts/install.sh | bash

Lo script verifica il download rispetto al file SHA256SUMS della release, non richiede sudo e installa in ~/.local. Oppure prendi l'AppImage dalla ultima release (chmod +x KRAKEN-*.AppImage, poi eseguilo; ./KRAKEN-*.AppImage kraken --help avvia la riga di comando), oppure su Arch Linux installa kraken-workbench-bin da AUR. Gli archivi per Windows e macOS sono anch'essi presenti nella pagina delle release, e sono sperimentali (vedi Stato). Installazione contiene i dettagli e la compilazione dai sorgenti.

Avvio rapido

kraken project-create --binary /usr/bin/ls --project ~/kraken-projects/ls
kraken analyze --project ~/kraken-projects/ls
kraken list-functions --project ~/kraken-projects/ls --limit 20
kraken-gui                             # or open the app and pick the project

I nuovi progetti usano il motore nativo quando riesce ad aprire il file, altrimenti il motore opzionale Ghidra (Mach-O, altri processori, informazioni di debug di Windows), che kraken setup scarica insieme a un JDK al primo utilizzo. La pagina del motore nativo confronta i due. I programmi di pratica in corpus/bin/ sono un buon punto di partenza, e il tutorial guida attraverso una prima sessione.

Collega un agente: claude mcp add kraken -- kraken mcp --project ~/kraken-projects/ls.

Dai sorgenti

Servono Rust e un compilatore C++:

git clone https://github.com/Adam-AtlasSoftware/kraken && cd kraken
cargo build --release -p kraken-cli -p krakend -p kraken-gui -p engine-native -p kraken-emu
export PATH="$PWD/target/release:$PATH"
kraken setup --native                  # once: fetches the pinned sources, compiles the Sleigh files (about a minute)

Documentazione

Inizia con il tutorial: la tua prima sessione di reverse engineering.

• Installazione e Guida introduttiva (terminale)
• Concetti per chi si avvicina al reverse engineering
• L'assistente integrato (un modello AI o un agente da terminale come Claude Code) e modelli locali su questo computer
• Connettere agenti AI (MCP)
• Scripting con la CLI e Python
• Sicurezza
• Riferimento dei comandi
• Decisioni di progettazione

Compila il libro con mdbook build docs. Il riferimento dei comandi è generato: esegui cargo xtask docs dopo aver modificato un comando.