
Reverse-Engineering-Tool mit integriertem MCP-Server: Eine KI kann dein Binary debuggen, nicht nur lesen — Breakpoints, Step-by-Step-Ausführung, Speicher, Funktionsaufrufe. Disassembler + Decompiler + Debugger im x64dbg-Stil in einem. Windows-GUI, Linux-CLI.
ein Disassembler, Decompiler und Debugger in einem — für Windows und Linux
IDA-artiges Listing, ein Decompiler, ein Funktionsgraph, ein x64dbg-artiger Debugger, Lua-Plugins und ein eingebauter MCP-Server, mit dem du eine KI auf eine Binärdatei ansetzen kannst — ein kleines Programm, alles mitgeliefert, nichts zu installieren, um es zu bauen.

ceasta zeigt denselben Code von den rohen Bytes bis zu lesbarem C, sodass du auf die Ebene wechseln kannst, die du gerade brauchst:
; 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
das ist djb2 (5381 ist 0x1505, und (h << 5) + h ist h * 33). der Decompiler arbeitet nach bestem Bemühen: noch keine Typen oder Structs, also liest man Register und Casts — großartig, um schnell eine Routine zu erfassen, während das Listing die Quelle der Wahrheit bleibt.
hol es dir von der Releases-Seite:
| Datei | Plattform | Was du bekommst |
|---|---|---|
ceasta-x.y.z-setup.exe | Windows 10/11 x64 | die vollständige App, installiert für deinen Benutzer (kein Admin), Startmenü + optionales „Mit ceasta öffnen“ |
ceasta-x.y.z-windows-x64.zip | Windows x64 | die vollständige App, portabel — entpacken und ceasta.exe ausführen |
ceasta-cli-x.y.z-linux-x64.tar.gz | Linux x64 | ceasta-cli + Plugins: Analyse, Disassembly, Decompiler, Skripting, Terminal-Debugger (unter Linux) |
ceasta-cli dbg) — Breakpoints, Stepping, Register, Speicher. einfach, aber echt; am besten bei Single-Threaded-Zielencall decrypt "..."), indirekte Aufrufziele als Xrefs aufzeichnen (trace)sigmake / sigapply)<binary>.ceasta danebenceasta-cli für Skripte und CIein Fenster, nichts schwebt herum:

der Decompiler (F5):

| Taste | Was | Taste | Was |
|---|---|---|---|
| Strg+O | eine Datei öffnen | Leertaste | Listing / Graph |
| G | zu Adresse oder Name springen | F5 | Pseudocode (Decompiler) |
| Enter / Doppelklick | dem Operanden folgen | Alt+B | Bytes suchen |
| Esc / Strg+Enter | zurück / vorwärts | F9 | Debuggen starten / fortsetzen |
| N | umbenennen | F7 / F8 | Step into / over |
| ; | Kommentar | F4 | bis zum Cursor ausführen |
| X | Referenzen hierher | F2 | Breakpoint umschalten |
| Strg+S | Namen und Kommentare speichern | F1 | alle Tastenkürzel |
Plugins sind Lua-Dateien in plugins/ (neben dem Programm) oder in %APPDATA%\ceasta\plugins. sie fügen Befehle zum Plugins-Menü hinzu. fünf sind dabei: Dateizusammenfassung, Crypto-Finder, Wrapper-Namer, Strings-Bericht, Call-Tracer (Debugger).
ceasta.register_command("Count calls", function()
local n = 0
for _, fn in ipairs(ceasta.functions()) do
n = n + #ceasta.xrefs_to(fn.addr)
end
ceasta.log(n .. " references to functions")
end)
die vollständige API steht im Lua-Skripting-Leitfaden. das Ausgabe-Panel hat auch eine Lua-Eingabeaufforderung — probiere ceasta.name(ceasta.here()).
ceasta-cli info file.exe format, entry, segments
ceasta-cli funcs file.exe functions
ceasta-cli disasm file.exe main 40 listing from a name or address
ceasta-cli graph file.exe start basic blocks of a function
ceasta-cli decompile file.exe main pseudocode for a function
ceasta-cli xrefs file.exe CreateFileW
ceasta-cli find file.exe "48 8b ?? 05"
ceasta-cli run file.exe script.lua run a plugin / script
ceasta-cli dbg ./program [args] interactive debugger (linux + windows)
ceasta-cli diff old.exe new.exe match functions, show what changed
ceasta-cli sigmake libc.a lib.sig make signatures from a file with symbols
ceasta-cli sigapply stripped lib.sig name matching functions
ceasta-cli mcp file.exe serve the file to an AI over MCP
richte eine KI (Claude Code, Claude Desktop, Cursor, ...) über ceastas eingebauten MCP-Server auf die Binärdatei aus:
claude mcp add ceasta -- ceasta-cli mcp /path/to/target.exe
sie kann dekompilieren, Xrefs lesen, Funktionen umbenennen, Builds vergleichen und — mit --allow-debug — Breakpoints setzen, steppen, Speicher lesen und sogar eine Funktion im laufenden Programm aufrufen. der vollständige Leitfaden, einschließlich der Debugger-Werkzeuge und der Sicherheitshinweise, steht in eine KI verbinden.
die GUI gibt es nur für Windows, aber das Kommandozeilenwerkzeug übernimmt Analyse, Disassembly, Decompiler, Skripting und einen Terminal-Debugger. hol dir ceasta-cli-x.y.z-linux-x64.tar.gz, entpacke und führe es aus — nichts weiter zu installieren:
tar xzf ceasta-cli-*-linux-x64.tar.gz
cd ceasta-cli-*-linux-x64
./ceasta-cli info /bin/ls format, entry, function / import / string counts
./ceasta-cli decompile /bin/ls start pseudocode for the entry point
./ceasta-cli run /bin/ls plugins/hello.lua run a lua plugin
./ceasta-cli dbg ./program debug it (break, step, registers, memory)
es liest ELF (x86 / x64) und Windows-PE-Dateien gleichermaßen, sodass du dir auch von Linux aus eine Windows-EXE ansehen kannst.
der Terminal-Debugger (dbg) ist ein ptrace-Debugger mit ceastas Namen, Disassembly und Decompiler eingebaut:
(ceasta) b main break at a name or address
(ceasta) c continue
(ceasta) ni / si step over / into until <addr> run to
(ceasta) r registers k stack x <addr> memory
(ceasta) u disassemble here (with names)
(ceasta) dec decompile the function you're stopped in
(ceasta) lua ... run lua against the live process
alles Nötige ist im Repo — nur ein Compiler, nichts herunterzuladen.
Windows
ceasta.sln, wähle Release | x64, baue → build\msvc\Releasecmake -S . -B build und dann cmake --build build --config Releasepowershell -ExecutionPolicy Bypass -File installer\package.ps1Linux (Core + CLI, die GUI gibt es nur für Windows)
cmake -S . -B build && cmake --build build -j
src/app.* — Zustand, Aktionen und das Hauptlayoutsrc/ui/ — eine Datei pro Panel (top_bar, left_panel, ida_view, graph_view, pseudo_view, right_panel, cpu_panel, bottom_panel, status_bar, dialogs)src/widgets/ — kleine gemeinsame Bausteine (nav_band, splitter)src/core/ — kein UI: Loader (binary, pe, elf), disasm (capstone), analysis, database, decompiler, lua_host, debugger (win32) + debugger_linux (ptrace), ossrc/cli/ — ceasta-cli und der dbg-Terminal-Debuggerplugins/ — Lua-Plugins, die mitgeliefert werdendocs/ — der Lua-Leitfaden, das Changelog, Lizenzen Dritter, Screenshotsinstaller/ — Inno-Setup-Skript und Packagingthird_party/ — imgui, capstone (nur x86), lua 5.4ceasta steht unter GPLv3. die mitgelieferten Bibliotheken behalten ihre eigenen (permissiven) Lizenzen — dear imgui und lua sind MIT, capstone ist BSD; Details in docs/THIRD_PARTY_NOTICES.md.