Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Einreichen
ToolsExploitsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

··Feeds·Kontakt·Datenschutz·© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
ceasta — 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. | Kitploit
Tools/GitHubGitHub/ngwg/ceasta
Statische AnalyseDynamische Analyse (Sandboxing)Reverse EngineeringScripting & AutomatisierungDebuggerMalware-AnalyseBinäranalyseKI-gestütztes Reverse EngineeringBinary-Exploitation
GitHubngwg/ceasta

ceasta

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.

2513vor 18h 16mVon Kitploit geprüft
Repository anzeigenWebseite

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen

ceasta

ceasta

ein Disassembler, Decompiler und Debugger in einem — für Windows und Linux

latest release platforms license c++17

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.

listing

eine Funktion, drei Ansichten

ceasta zeigt denselben Code von den rohen Bytes bis zu lesbarem C, sodass du auf die Ebene wechseln kannst, die du gerade brauchst:

root@kitploit:~
; 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.

download

hol es dir von der Releases-Seite:

DateiPlattformWas du bekommst
ceasta-x.y.z-setup.exeWindows 10/11 x64die vollständige App, installiert für deinen Benutzer (kein Admin), Startmenü + optionales „Mit ceasta öffnen“
ceasta-x.y.z-windows-x64.zipWindows x64die vollständige App, portabel — entpacken und ceasta.exe ausführen
ceasta-cli-x.y.z-linux-x64.tar.gzLinux x64ceasta-cli + Plugins: Analyse, Disassembly, Decompiler, Skripting, Terminal-Debugger (unter Linux)

was es macht

  • öffnet PE-Dateien (exe, dll, sys — 32 und 64 Bit), ELF (x86 / x64) und rohen Shellcode
  • automatische Analyse: Funktionen (Entry, Exporte, Symbole, .pdata, TLS-Callbacks, Aufrufe, Zeiger in Daten), Switch-Tabellen, Xrefs, Strings (ASCII + UTF-16), Importe / Exporte, Thunks, Noreturn-Aufrufe
  • IDA-artiges Listing: Namen statt Adressen, Labels, Xref- und String-Kommentare
  • Funktionsgraph (Leertaste): farbige Kanten, Zoom mit Strg + Mausrad, Ziehen zum Verschieben
  • Decompiler (F5): C-artiger Pseudocode für eine Funktion — if / else, while / do, switch, Aufrufe mit Namen
  • Debugger: starten oder anhängen, Breakpoints, Step into / over, bis zum Cursor ausführen, Pause, Register, Stack, Live-Speicher
    • Windows: vollständiger GUI-Debugger + Terminal, Win32 Debug API, 32-Bit über WOW64
    • Linux: ein Terminal-Debugger auf Basis von ptrace (ceasta-cli dbg) — Breakpoints, Stepping, Register, Speicher. einfach, aber echt; am besten bei Single-Threaded-Zielen
  • Decompiler während des Debuggens: im Halt in einer Funktion markiert der Pseudocode die aktuelle Zeile
  • eine Funktion im laufenden Programm aufrufen (call decrypt "..."), indirekte Aufrufziele als Xrefs aufzeichnen (trace)
  • Binärvergleich: Funktionen zwischen zwei Builds abgleichen und sehen, was sich geändert hat
  • Bibliothekssignaturen: bekannte Funktionen in einer gestrippten Binärdatei benennen (sigmake / sigapply)
  • ein eingebauter MCP-Server: eine KI (Claude Code, Cursor, ...) mit der geöffneten Binärdatei verbinden — siehe eine KI verbinden
  • Umbenennen, Kommentare, Sprung zu Adresse oder Name, Xrefs, Byte-Suche, zurück / vorwärts
  • Namen, Kommentare und Breakpoints werden pro Datei gespeichert, und in eine committbare <binary>.ceasta daneben
  • Lua-Plugins und eine Lua-Konsole; ceasta-cli für Skripte und CI

Layout

ein Fenster, nichts schwebt herum:

  • oben: Menü und Toolbar
  • links: Funktionen
  • Mitte: Übersichtsband, dann das Listing, der Graph oder der Pseudocode
  • rechts: Importe / Exporte / Strings / Segmente / Xrefs, mit dem Debugger (Register + Stack) darunter
  • unten: Ausgabe + Lua-Konsole, Hex, Breakpoints, Module
  • ziehe die Linien zwischen den Panels zum Größenändern, das Ansicht-Menü blendet Panels aus und wechselt das Theme, Strg + / Strg - ändert die Textgröße

graph

der Decompiler (F5):

pseudocode

Tasten

TasteWasTasteWas
Strg+Oeine Datei öffnenLeertasteListing / Graph
Gzu Adresse oder Name springenF5Pseudocode (Decompiler)
Enter / Doppelklickdem Operanden folgenAlt+BBytes suchen
Esc / Strg+Enterzurück / vorwärtsF9Debuggen starten / fortsetzen
NumbenennenF7 / F8Step into / over
;KommentarF4bis zum Cursor ausführen
XReferenzen hierherF2Breakpoint umschalten
Strg+SNamen und Kommentare speichernF1alle Tastenkürzel

Plugins

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).

root@kitploit:~
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()).

CLI

root@kitploit:~
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

eine KI verbinden

richte eine KI (Claude Code, Claude Desktop, Cursor, ...) über ceastas eingebauten MCP-Server auf die Binärdatei aus:

root@kitploit:~
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.

unter Linux

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:

root@kitploit:~
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:

root@kitploit:~
(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

Build

alles Nötige ist im Repo — nur ein Compiler, nichts herunterzuladen.

Windows

  • Visual Studio 2022: öffne ceasta.sln, wähle Release | x64, baue → build\msvc\Release
  • oder CMake: cmake -S . -B build und dann cmake --build build --config Release
  • Release-Dateien (Zip + Installer, benötigt Inno Setup 6): powershell -ExecutionPolicy Bypass -File installer\package.ps1

Linux (Core + CLI, die GUI gibt es nur für Windows)

root@kitploit:~
cmake -S . -B build && cmake --build build -j

Code

  • src/app.* — Zustand, Aktionen und das Hauptlayout
  • src/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), os
  • src/cli/ — ceasta-cli und der dbg-Terminal-Debugger
  • plugins/ — Lua-Plugins, die mitgeliefert werden
  • docs/ — der Lua-Leitfaden, das Changelog, Lizenzen Dritter, Screenshots
  • installer/ — Inno-Setup-Skript und Packaging
  • third_party/ — imgui, capstone (nur x86), lua 5.4

Lizenz

ceasta 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.

Tool herunterladen