ceasta

un disassembler, decompilatore e debugger in uno — per windows, linux e macos, x86, x64 e arm64

listing in stile ida, un decompilatore, un grafo delle funzioni, un debugger in stile x64dbg, plugin lua e un server MCP integrato per poter puntare un'AI su un binario — un piccolo programma, tutto incluso, niente da installare per compilare.

una funzione, tre modi

ceasta mostra lo stesso codice dai byte grezzi fino a c leggibile, così puoi scendere al livello che ti serve:

; assembly - the real instructions  // pseudocode (f5) - reconstructed c

checksum proc                       int checksum(int rdi)
  movzx   edx, byte ptr [rdi]       {
  test    dl, dl                        rdx = *(char*)rdi;
  je      loc_1191                      if (rdx == 0) {
  mov     eax, 0x1505                       return 0x1505;
loc_1179:                               }
  mov     ecx, eax                      rax = 0x1505;
  shl     ecx, 5                        do {
  add     eax, ecx                          rax = rax + (rax << 5) + rdx;
  add     rdi, 1                            rdi = rdi + 1;
  movzx   edx, dl                           rdx = *(char*)rdi;
  add     eax, edx                      } while (rdx != 0);
  movzx   edx, byte ptr [rdi]           return rax;
  test    dl, dl                    }
  jne     loc_1179
  ret
loc_1191:
  mov     eax, 0x1505
  ret

che è djb2 (5381 è 0x1505, e (h << 5) + h è h * 33). fai clic su un nome nello pseudocodice e assegna i nomi come li comprendi — y sulla funzione le assegna un prototipo, n rinomina una variabile:

unsigned checksum(const char* s)
{
    rdx = *(char*)s;
    if (rdx == 0) {
        return 0x1505;
    }
    h = 0x1505;
    do {
        h = h + (h << 5) + rdx;
        s = s + 1;
        rdx = *(char*)s;
    } while (rdx != 0);
    return h;
}

il decompilatore è best-effort (x86 / x64, ancora senza struct) — ottimo per ottenere rapidamente una routine, mentre il listing resta la fonte di verità.

download

scaricalo dalla pagina delle release:

file	piattaforma	cosa ottieni
ceasta-x.y.z-setup.exe	windows 10/11 x64	l'app completa, si installa per il tuo utente (senza admin), menu start + opzionale "apri con ceasta"
ceasta-x.y.z-windows-x64.zip	windows x64	l'app completa, portabile — decomprimi ed esegui ceasta.exe
ceasta-x.y.z-linux-x64.AppImage	linux x64	l'app completa — chmod +x ed esegui (su linux)
ceasta-cli-x.y.z-linux-x64.tar.gz	linux x64	ceasta-cli + plugin: analisi, disassemblaggio, decompilatore, scripting, debugger da terminale, diff di binari, firme e il server MCP
ceasta-x.y.z-macos.dmg	macos 11+, apple silicon e intel	l'app, ancora senza debugger — trascinala in Applicazioni (su un mac)
ceasta-cli-x.y.z-macos.tar.gz	macos 11+, apple silicon e intel	ceasta-cli + plugin, tutto quanto sopra tranne il debugger

cosa fa

• apre file PE (exe, dll, sys — x86, x64 e arm64), elf (x86, x64, arm64), mach-o (programmi e librerie macos / ios, x86_64 e arm64, anche file universal) e codice grezzo
• analisi automatica: funzioni (entry, export, simboli, .pdata, tabelle di unwind, function starts mach-o, callback tls, chiamate, puntatori nei dati), tabelle switch, xref, stringhe (ascii + utf-16), import / export, thunk, chiamate noreturn
• listing in stile ida: nomi invece di indirizzi, etichette, commenti xref e stringhe, gli argomenti che ogni istruzione passa a un'api nota
• grafo delle funzioni (spazio): archi colorati, zoom con ctrl + rotella, trascina per spostare
• decompilatore (f5, x86 / x64): pseudocodice in stile c — if / else, cicli, switch, variabili di stack, chiamate con i loro argomenti (~350 prototipi di api note). clicca un nome: n lo rinomina, y imposta un tipo o un prototipo. shift+f5 lo mostra accanto al listing
• un secondo decompilatore se ne vuoi uno: con kuna installato (un decompilatore portato da quello di ghidra), la vista pseudocodice ottiene un interruttore kuna — il suo output per la stessa funzione, righe collegate al listing, anche arm64. maggiori dettagli sotto
• informazioni sul file: header, flag di sicurezza (aslr, dep, cfg / pie, nx, relro, canary / hardened runtime), md5 / sha256 / imphash, entropia delle sezioni, risorse, informazioni sulla versione, la firma del codice e gli entitlement di un programma mac, e avvisi quando sembra packato
• cerca tutto (ctrl+f): funzioni, nomi, import, export, stringhe, commenti e segmenti in un'unica casella, e le stringhe indicano dove sono usate
• debugger (x86 / x64, windows e linux): avvia o aggancia, breakpoint (con condizioni: rdi == 3), watchpoint sulle variabili, step into / over / out, step back, esegui fino al cursore, pausa, registri, stack, call stack, mappa della memoria, memoria live
  • lo pseudocodice contrassegna la riga su cui sei fermo
  • chiama una funzione nel programma in esecuzione (call decrypt "..."), registra i target delle chiamate indirette come xref (trace)
  • ceasta-cli dbg: lo stesso debugger in un terminale
• diff binario: confronta le funzioni tra due build e vedi cosa è cambiato
• firme delle librerie: assegna un nome alle funzioni note in un binario stripped (sigmake / sigapply)
• un server MCP integrato: collega un'AI (Claude Code, Cursor, ...) al binario aperto dal menu AI, oppure con ceasta-cli mcp — con prompt pronti all'uso, e nomi che revisioni prima che vengano applicati. vedi collegare un'AI
• rinomina, commenti, segnalibri, salto a indirizzo o nome, xref, ricerca di byte, indietro / avanti, annulla / ripristina, e ogni azione in un unico elenco (ctrl+shift+p)
• il tuo lavoro in un unico file, come il .i64 di ida: ctrl+s scrive <file>.ceasta con i tuoi nomi, commenti, tipi, breakpoint e il programma stesso — si apre in seguito, o su un'altra macchina, senza l'originale. alla chiusura viene chiesto prima di scartare il lavoro non salvato
• scambia nomi con altri strumenti: esporta uno script idapython, uno script ghidra o un database x64dbg; importa da x64dbg, file .map, e ida / ghidra (con gli script in scripts/)
• plugin lua e una console lua; ceasta-cli per script e ci

layout

una sola finestra, niente che fluttua: