Skip to content
Back to search

ceasta

disassembler, decompiler and debugger in one, with a built-in mcp server: point an ai at a binary and it can debug it, not just read it. ida-style listing, pseudocode (f5), x64dbg-style debugger (windows and linux), binary diff, lua plugins. reads pe, elf and mach-o. runs on windows, linux and macos.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ngwg--ceasta/badge.svg)](/listings/ngwg--ceasta)

HTML

<a href="/listings/ngwg--ceasta"><img src="/api/listings/ngwg--ceasta/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 308 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="docs/icon.png" width="96" height="96" alt="ceasta">
  3. </p>
  4. <h1 align="center">ceasta</h1>
  5. <p align="center">a disassembler, decompiler and debugger in one — for windows, linux and macos, x86, x64 and arm64</p>
  6. <p align="center">
  7. <a href="https://github.com/ngwg/ceasta/releases"><img src="https://img.shields.io/github/v/release/ngwg/ceasta?color=2ea043&label=release" alt="latest release"></a>
  8. <img src="https://img.shields.io/badge/platform-windows%20%7C%20linux%20%7C%20macos-555" alt="platforms">
  9. <a href="LICENSE"><img src="https://img.shields.io/github/license/ngwg/ceasta?color=blue" alt="license"></a>
  10. <img src="https://img.shields.io/badge/c%2B%2B-17-00599C" alt="c++17">
  11. </p>
  12. ida-style listing, a decompiler, a function graph, an x64dbg-style debugger, lua plugins, and a built-in MCP server so you can point an AI at a binary — one small program, everything vendored, nothing to install to build.
  13. ![listing](docs/listing.png)
  14. ## one function, three ways
  15. ceasta shows the same code from raw bytes up to readable c, so you can drop to whatever level you need:
  16. ```text
  17. ; assembly - the real instructions // pseudocode (f5) - reconstructed c
  18. checksum proc int checksum(int rdi)
  19. movzx edx, byte ptr [rdi] {
  20. test dl, dl rdx = *(char*)rdi;
  21. je loc_1191 if (rdx == 0) {
  22. mov eax, 0x1505 return 0x1505;
  23. loc_1179: }
  24. mov ecx, eax rax = 0x1505;
  25. shl ecx, 5 do {
  26. add eax, ecx rax = rax + (rax << 5) + rdx;
  27. add rdi, 1 rdi = rdi + 1;
  28. movzx edx, dl rdx = *(char*)rdi;
  29. add eax, edx } while (rdx != 0);
  30. movzx edx, byte ptr [rdi] return rax;
  31. test dl, dl }
  32. jne loc_1179
  33. ret
  34. loc_1191:
  35. mov eax, 0x1505
  36. ret
  37. ```
  38. that's djb2 (5381 is `0x1505`, and `(h << 5) + h` is `h * 33`). click a name in the pseudocode and name things as you understand them — `y` on the function gives it a prototype, `n` renames a variable:
  39. ```c
  40. unsigned checksum(const char* s)
  41. {
  42. rdx = *(char*)s;
  43. if (rdx == 0) {
  44. return 0x1505;
  45. }
  46. h = 0x1505;
  47. do {
  48. h = h + (h << 5) + rdx;
  49. s = s + 1;
  50. rdx = *(char*)s;
  51. } while (rdx != 0);
  52. return h;
  53. }
  54. ```
  55. the decompiler is best-effort (x86 / x64, no structs yet) — great for getting a routine quickly, while the listing stays the source of truth.
  56. ## download
  57. grab it from the [releases page](https://github.com/ngwg/ceasta/releases):
  58. | file | platform | what you get |
  59. |------|----------|--------------|
  60. | `ceasta-x.y.z-setup.exe` | windows 10/11 x64 | the full app, installs for your user (no admin), start menu + optional "open with ceasta" |
  61. | `ceasta-x.y.z-windows-x64.zip` | windows x64 | the full app, portable — unzip and run `ceasta.exe` |
  62. | `ceasta-x.y.z-linux-x64.AppImage` | linux x64 | the full app — `chmod +x` and run ([on linux](#on-linux)) |
  63. | `ceasta-cli-x.y.z-linux-x64.tar.gz` | linux x64 | `ceasta-cli` + plugins: analysis, disassembly, decompiler, scripting, terminal debugger, binary diff, signatures, and the [MCP server](docs/mcp.md) |
  64. | `ceasta-x.y.z-macos.dmg` | macos 11+, apple silicon and intel | the app, no debugger yet — drag it to Applications ([on a mac](#on-a-mac)) |
  65. | `ceasta-cli-x.y.z-macos.tar.gz` | macos 11+, apple silicon and intel | `ceasta-cli` + plugins, everything above but the debugger |
  66. ## what it does
  67. - opens pe files (exe, dll, sys — x86, x64 and arm64), elf (x86, x64, arm64), mach-o (macos / ios programs and libraries, x86_64 and arm64, universal files too) and raw code
  68. - auto analysis: functions (entry, exports, symbols, .pdata, unwind tables, mach-o function starts, tls callbacks, calls, pointers in data), switch tables, xrefs, strings (ascii + utf-16), imports / exports, thunks, noreturn calls
  69. - ida-style listing: names instead of addresses, labels, xref and string comments, the arguments each instruction passes to a known api
  70. - function graph (space): colored edges, zoom with ctrl + wheel, drag to pan
  71. - decompiler (f5, x86 / x64): c-like pseudocode — if / else, loops, switch, stack variables, calls with their arguments (~350 known api prototypes). click a name: `n` renames it, `y` sets a type or a prototype. shift+f5 shows it next to the listing
  72. - a second decompiler if you want one: with [kuna](https://github.com/Noelo-Lab/kuna) installed (a decompiler ported from ghidra's), the pseudocode view gets a `kuna` switch — its output for the same function, lines linked to the listing, arm64 too. [more below](#second-decompiler-kuna)
  73. - file info: headers, security flags (aslr, dep, cfg / pie, nx, relro, canary / hardened runtime), md5 / sha256 / imphash, section entropy, resources, version info, a mac program's code signature and entitlements, and warnings when it looks packed
  74. - search everything (ctrl+f): functions, names, imports, exports, strings, comments and segments in one box, and the strings say where they're used
  75. - debugger (x86 / x64, windows and linux): start or attach, breakpoints (with conditions: `rdi == 3`), watchpoints on variables, step into / over / out, step back, run to cursor, pause, registers, stack, call stack, memory map, live memory
  76. - the pseudocode marks the line you're stopped on
  77. - call a function in the running program (`call decrypt "..."`), record indirect call targets as xrefs (`trace`)
  78. - `ceasta-cli dbg`: the same debugger in a terminal
  79. - binary diff: match functions between two builds and see what changed
  80. - library signatures: name known functions in a stripped binary (`sigmake` / `sigapply`)
  81. - a built-in MCP server: connect an AI (Claude Code, Cursor, ...) to the open binary from the AI menu, or with `ceasta-cli mcp` — with ready-made prompts, and names you review before they're applied. see [connect an AI](docs/mcp.md)
  82. - rename, comments, bookmarks, jump to address or name, xrefs, byte search, back / forward, undo / redo, and every action in one list (ctrl+shift+p)
  83. - your work in one file, like ida's `.i64`: ctrl+s writes `<file>.ceasta` with your names, comments, types, breakpoints and the program itself — it opens later, or on another machine, without the original. closing asks before it throws unsaved work away
  84. - trade names with other tools: export an idapython script, a ghidra script or an x64dbg database; import from x64dbg, `.map` files, and ida / ghidra (with the scripts in `scripts/`)
  85. - lua plugins and a lua console; `ceasta-cli` for scripts and ci
  86. ## layout
  87. one window, nothing floating around:
  88. - top: menu and toolbar
  89. - left: functions
  90. - middle: overview band, then the listing, the graph, the pseudocode, or listing and pseudocode side by side
  91. - right: imports / exports / strings / file info / xrefs, with the debugger (registers + stack) under it while debugging
  92. - bottom: output + lua console, hex, breakpoints — and call stack and memory while debugging
  93. - drag the lines between panels to resize, the view menu hides panels and switches theme, ctrl + / ctrl - changes the text size
  94. ![graph](docs/graph.png)
  95. the decompiler (f5), here next to the listing (shift+f5) — a click in one moves the other:
  96. ![pseudocode](docs/pseudo.png)
  97. ## keys
  98. | key | what | key | what |
  99. |-----|------|-----|------|
  100. | ctrl+o | open a file (or a `.ceasta`) | space | listing / graph |
  101. | g | jump to address or name | f5 / shift+f5 | pseudocode / next to the listing |
  102. | ctrl+f | search names, imports, strings, ... | alt+b | search bytes |
  103. | enter / double click | follow the operand | f9 | start debugging / continue |
  104. | esc / ctrl+enter | back / forward | f7 / f8 | step into / over (n at once: the box by the step buttons) |
  105. | n | rename (in the pseudocode too) | ctrl+f9 / shift+f7 | step out / step back |
  106. | y | type / prototype (pseudocode) | f4 | run to cursor |
  107. | ; | comment | f2 | breakpoint (on data: watch it) |
  108. | x | references to here | shift+f2 | breakpoint condition |
  109. | alt+m / ctrl+m | bookmark / bookmarks | f12 | pause |
  110. | ctrl+z / ctrl+y | undo / redo | ctrl+s | save |
  111. | ctrl+shift+p | every action | f1 | all shortcuts |
  112. ## plugins
  113. plugins are lua files in `plugins/` (next to the program) or in your own plugins folder (`%APPDATA%\ceasta\plugins`, `~/.config/ceasta/plugins`). they add commands to the plugins menu. five come with it: file summary, crypto finder, wrapper namer, strings report, call tracer (debugger).
  114. ```lua
  115. ceasta.register_command("Count calls", function()
  116. local n = 0
  117. for _, fn in ipairs(ceasta.functions()) do
  118. n = n + #ceasta.xrefs_to(fn.addr)
  119. end
  120. ceasta.log(n .. " references to functions")
  121. end)
  122. ```
  123. the whole api is in the [lua scripting guide](docs/lua.md). the output panel has a lua prompt too — try `ceasta.name(ceasta.here())`.
  124. ## cli
  125. ```
  126. ceasta-cli info file.exe headers, security flags, hashes, sections, warnings
  127. ceasta-cli funcs file.exe functions
  128. ceasta-cli disasm file.exe main 40 listing from a name or address
  129. ceasta-cli graph file.exe start basic blocks of a function
  130. ceasta-cli decompile file.exe main pseudocode for a function (--kuna: kuna's)
  131. ceasta-cli xrefs file.exe CreateFileW
  132. ceasta-cli find file.exe "48 8b ?? 05"
  133. ceasta-cli search file.exe usage find text in names, imports, strings, comments
  134. ceasta-cli run file.exe script.lua run a plugin / script
  135. ceasta-cli dbg ./program [args] interactive debugger (linux + windows)
  136. ceasta-cli diff old.exe new.exe match functions, show what changed
  137. ceasta-cli sigmake libc.a lib.sig make signatures from a file with symbols
  138. ceasta-cli sigapply stripped lib.sig name matching functions
  139. ceasta-cli export file.exe --ida out.py your names for ida (--ghidra, --x64dbg too)
  140. ceasta-cli import file.exe names.json names from x64dbg, a .map, ida or ghidra
  141. ceasta-cli mcp file.exe serve the file to an AI over MCP
  142. ```
  143. `--raw32` / `--raw64` / `--raw-arm64` (and `--base <hex>`) load a file as raw code.
  144. ## second decompiler: kuna
  145. [kuna](https://github.com/Noelo-Lab/kuna) is a decompiler ported from ghidra's (apache-2.0). ceasta doesn't ship it — it runs kuna's command line tool when you have it:
  146. - install kuna the way its readme says and put `kuna` on your PATH, or point ceasta at it: view > second decompiler (kuna)...
  147. - the pseudocode view then has a `ceasta | kuna` switch. kuna's output is read-only and uses its own names (`sub_401000`, `dat_404010`), but its lines are linked to the listing like ceasta's, and a click on `sub_...` jumps there
  148. - it reads arm64 too, where ceasta's own decompiler stops
  149. - `ceasta-cli decompile file main --kuna` (or `--kuna-path /path/to/kuna`), and the AI gets a `decompile_with_kuna` tool
  150. ## connect an AI
  151. point an AI (Claude Code, Claude Desktop, Cursor, ...) at the binary through ceasta's built-in
  152. MCP server. in the app: **AI > Connect an AI...**, start the server, and paste the command it
  153. shows into your client:
  154. ```
  155. claude mcp add --transport http ceasta http://127.0.0.1:8744/mcp
  156. ```
  157. the AI then works on what you have open — its renames and comments appear as it goes, and with
  158. the debugger allowed you watch it set breakpoints and step. without the app:
  159. ```
  160. claude mcp add ceasta -- ceasta-cli mcp /path/to/target.exe
  161. ```
  162. it can decompile, read xrefs, rename functions and variables, set prototypes, diff builds, and —
  163. with the debugger allowed (`--allow-debug`) — set breakpoints and watchpoints, step (and step
  164. back), read memory and even call a function in the running program. ready-made prompts
  165. (`triage`, `explain_function`, `rename_pass`, `find_crypto`, `trace_function`) show up as
  166. commands in the client, and the names it suggests wait for you in **AI > Review suggested
  167. names**. the full guide, including the debugger tools and the safety notes, is in
  168. [connect an AI](docs/mcp.md).
  169. ## on linux
  170. the full app is an AppImage: download `ceasta-x.y.z-linux-x64.AppImage`, make it executable and run it — nothing to install (ubuntu 22.04 or newer, or a distro of the same age). it needs an x11 or wayland desktop with opengl 3; file dialogs use zenity or kdialog when they're there, and you can always drop a file on the window.
  171. ```
  172. chmod +x ceasta-*-linux-x64.AppImage
  173. ./ceasta-*-linux-x64.AppImage /bin/ls
  174. ```
  175. if it complains about fuse, run it with `--appimage-extract-and-run`. the debugger is the same one as on windows (ptrace underneath); `/proc/sys/kernel/yama/ptrace_scope` may need to be 0 to attach to a running process.
  176. for servers and scripts there's the command line tool, `ceasta-cli-x.y.z-linux-x64.tar.gz`: the analysis, disassembly, decompiler, scripting, a terminal debugger, binary diff, signatures and the mcp server. unpack and run:
  177. ```
  178. tar xzf ceasta-cli-*-linux-x64.tar.gz
  179. cd ceasta-cli-*-linux-x64
  180. ./ceasta-cli info /bin/ls headers, hashes, sections, warnings
  181. ./ceasta-cli decompile /bin/ls start pseudocode for the entry point
  182. ./ceasta-cli run /bin/ls plugins/hello.lua run a lua plugin
  183. ./ceasta-cli dbg ./program debug it (break, step, registers, memory)
  184. ```
  185. both read elf, windows pe and mac mach-o files alike (x86, x64, arm64), so you can look at a windows exe — or an arm64 phone or server binary, or a mac app — from linux too.
  186. the terminal debugger (`dbg`) is a ptrace debugger with ceasta's names, disassembly and decompiler built in:
  187. ```
  188. (ceasta) b main break at a name or address
  189. (ceasta) c continue
  190. (ceasta) ni / si step over / into until <addr> run to
  191. (ceasta) r registers k stack x <addr> memory
  192. (ceasta) u disassemble here (with names)
  193. (ceasta) dec decompile the function you're stopped in
  194. (ceasta) bt / maps call stack / memory map
  195. (ceasta) watch <addr> stop when it's written (awatch: read or written)
  196. (ceasta) back / finish step back / step out
  197. (ceasta) lua ... run lua against the live process
  198. ```
  199. ## on a mac
  200. the app comes as `ceasta-x.y.z-macos.dmg`: open it and drag ceasta to Applications. one app runs on apple silicon and intel macs (macos 11 or newer). it's signed ad-hoc but not notarized by apple, so the first time macos stops it — right-click ceasta.app > **Open** (on macos 15 and later: System Settings > Privacy & Security > **Open Anyway**), or once in a terminal:
  201. ```
  202. xattr -dr com.apple.quarantine /Applications/ceasta.app
  203. ```
  204. the shortcuts use cmd where the others use ctrl (cmd+s, cmd+z, cmd+shift+p, ...). plugins you add go in `~/Library/Application Support/ceasta/plugins`.
  205. it reads mach-o files: programs, libraries, bundles and `.o` files, x86_64 and arm64 (arm64e too, apple's own). names show without the underscore mach-o puts in front (`main`, `printf`), like on the other systems. a universal file opens its x86_64 part (the decompiler reads it) and the arm64 part is one cmd+shift+p away ("part"), or `--arch arm64` on the command line. the file tab shows what a mac program says about itself: the minimum macos and sdk, the libraries and rpaths, the code signature (who signed it, hardened runtime, library validation) and its entitlements, with a warning for the ones that let code in (`get-task-allow`, `disable-library-validation`, dyld environment variables, jit). to read an app, open the program inside it: the open panel goes into `.app` bundles (Contents/MacOS/...).
  206. ```
  207. ./ceasta-cli info /bin/ls universal, arm64e, signed by apple
  208. ./ceasta-cli funcs /bin/ls --arch arm64 the arm64 part
  209. ./ceasta-cli decompile /Applications/Foo.app/Contents/MacOS/Foo main
  210. ```
  211. there's no debugger on macos yet: that needs apple's debugging interfaces and a signed, entitled build. the windows and linux builds have one, and they read mac files too.
  212. ## build
  213. everything needed is in the repo — just a compiler, nothing to fetch.
  214. **windows**
  215. - visual studio 2022: open `ceasta.sln`, pick `Release | x64`, build → `build\msvc\Release`
  216. - or cmake: `cmake -S . -B build` then `cmake --build build --config Release`
  217. - release files (zip + installer, needs [inno setup 6](https://jrsoftware.org/isinfo.php)): `powershell -ExecutionPolicy Bypass -File installer\package.ps1`
  218. **linux** (core + cli)
  219. ```
  220. cmake -S . -B build && cmake --build build -j
  221. ```
  222. **linux gui** (needs `libglfw3-dev` and an opengl dev package; ci packs it into the AppImage with linuxdeploy, see `.github/workflows/build.yml`)
  223. ```
  224. cmake -S . -B build -DCEASTA_LINUX_GUI=ON && cmake --build build -j
  225. ```
  226. **macos** (the app needs glfw: `brew install glfw`; without it only `ceasta-cli` is built)
  227. ```
  228. cmake -S . -B build && cmake --build build -j # build/ceasta.app and build/ceasta-cli
  229. ```
  230. ci builds glfw and ceasta for arm64 and x86_64 at once (`-DCMAKE_OSX_ARCHITECTURES="arm64;x86_64"`) and packs the dmg, see `.github/workflows/build.yml`.
  231. ## code
  232. - `src/app.*` — state, actions and the main layout; `src/app_mcp.cpp` runs the AI server from the app
  233. - `src/ui/` — one file per panel (top_bar, left_panel, ida_view, graph_view, pseudo_view, right_panel, cpu_panel, bottom_panel, status_bar, dialogs)
  234. - `src/widgets/` — small shared bits (nav_band, splitter)
  235. - `src/core/` — no ui: loaders (`binary`, `pe`, `elf`, `macho`), `fileinfo`, `disasm` (capstone), `analysis`, `database`, `search`, `decompiler`, `protos` (known api prototypes), `lua_host`, `debugger` (win32) + `debugger_linux` (ptrace) + `dbg_stack` (call stacks), `mcp` + `mcp_transport` (the AI server), `diff`, `signatures`, `exchange` (ida / ghidra / x64dbg), `os`
  236. - `src/cli/` — ceasta-cli and the `dbg` terminal debugger
  237. - `plugins/` — lua plugins that ship with it
  238. - `scripts/` — `ida_to_ceasta.py` and `ghidra_to_ceasta.py`: your names from those tools, for file > import names
  239. - `docs/` — the [lua guide](docs/lua.md), the [changelog](docs/CHANGELOG.md), third-party licenses, screenshots
  240. - `installer/` — inno setup script and packaging; `packaging/linux/` — the AppImage's desktop entry and icon; `packaging/macos/` — the app's Info.plist and icon; `src/mac_platform.mm` — the mac open / save panels
  241. - `third_party/` — imgui, capstone (x86 and arm64), lua 5.4
  242. ## license
  243. ceasta is [GPLv3](LICENSE). the vendored libraries keep their own (permissive) licenses — dear imgui and lua are MIT, capstone is BSD; details in [docs/THIRD_PARTY_NOTICES.md](docs/THIRD_PARTY_NOTICES.md).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.