- Home
- Skills
- Mobile Development
- rekit - Binary, APK & web Reverse Engineering
More screenshots
Works with the AI Agents you already use
rekit - Binary, APK & web Reverse Engineering
Reverse-engineers binaries, APKs and web bundles with 36 tools: identify the file, find the check, then run it in a sandbox and read the real return value instead of guessing from decompiled code.
$24
rekit - Binary, APK & web Reverse Engineering
Example session with this skill installed
I'm assessing an Android app; its native library refuses the licence key the
vendor gave me. Find what it actually checks, and tell me which value passes.
- Read your context and instructions
- Compiled the rekit - binary
-
rekit_info → ELF 64 little (x86-64), 16.0 KiB, 27 sections,
sha256 276cdff4…1985bd -
rekit_scan kind=apis
anti: ptrace
file: fopen, fclose
other: strncmp, strlen, snprintf, fgets, strcmp, hypot, atoi, getppid, strdup
→ it checks for a debugger and reads /proc/self/status, and the comparison is
strncmp/strcmp, not a hash. The function that calls both is the gate. -
rekit_emulate symbol=keygen args=4919
arch x86_64 / linux · stop returned · return 0x1 (1) · calls strdup x1 · 0 ms
→ the function finished and said yes, so the gate is one comparison. -
rekit_fuzz symbol=keygen mode=magic target=1 start=4000 end=6000
runs 2001 · looking for a return of 1 · found 1 input(s): 4919 -> 0x1
→ keygen: one value out of two thousand. -
rekit_emulate symbol=t_dup read-ret=16
return 0x20000000 · calls strdup x1
read ret 0x20000000 656d756c6174656420737472696e6700|emulated string.|→ when a function returns a pointer, --read-ret shows what it points at.
Answer
The check is an integer equality; the accepted value is 4919. The anti-debug
guard never fired, because the sandbox answers ptrace, getppid and
/proc/self/status itself. No decompiler was opened, and every line above is a
call the agent made.
Connects securely to your tools. The creator never sees your data.
About this skill
### Reverse engineering, without the guesswork
Decompiled code tells your agent what a program *could* do. It does not tell it
what a licence check returns for `ABCD-1234`, what a decryption actually
produced, or which request a web app fires on load. Those are the questions that
matter, and this skill is built around answering them.
It teaches your agent to drive **rekit** — one MCP server with 35
reverse-engineering tools — in the order an experienced analyst works:
identify the file, profile its intent from imports and strings, read only the
function that matters, then *run* it in a sandbox and read the return value,
registers and memory.
### What your agent can do with it
- Identify any ELF, PE, Mach-O, APK, dex, jar, .NET assembly or firmware image:
architecture, sections, packing, hashes.
- Find where a check lives, then execute it: what it returns, which imports it
really calls, what it wrote into the buffer, where it faulted.
- Turn a boolean check into a keygen: sweep the input space, find the threshold,
find the input that passes.
- Read native libraries straight out of an APK (`app.apk::lib/arm64-v8a/lib.so`)
without unpacking anything.
- Recover hardcoded keys, tokens, JWTs and API routes from an app or a frontend
bundle — masked by default.
- Drive a real headless browser to see what a page actually sends: requests with
their status and cookies, the console, storage, a screenshot, a PDF.
- Patch a branch, then re-run the function to prove the patch changed the answer.
- Triage a crash to an address, and hook a real process when the sandbox is not
enough.
### Why not just ask the agent to run Ghidra?
Because a decompiler plus a language model is a confident guess, and here a
confident guess is worse than no answer. The skill encodes the order of work
that avoids it — cheap facts first (`info`, `entropy`, `scan`, `strings`), the
decompiler only for one function, emulation for the verdict — and the two traps
that catch most agents: an import answered with a default (`unimplemented`)
silently invalidating a conclusion, and integer versus floating-point arguments
landing in different registers.
### What is inside
rekit/ ├── SKILL.md the method: tool choice, order, reporting, limits ├── references/tools.md all 35 tools, parameters, what each returns ├── references/emulation.md argument typing per ABI, stubs, fuzzing, sandbox limits ├── references/workflows.md seven playbooks: triage, failing check, APK, front end, │ patch-and-verify, crash triage, memory dump └── scripts/check.sh read-only install check, no network
About 1,000 lines written against the tool, not around it: every call in the
playbooks is one the server accepts, and the outputs shown come from real runs.
### Requirements
- `rekit` installed — free and MIT, one command:
`cargo install --git https://github.com/Nevers1/rekit rekit-cli`
- For emulation: `cargo install --git https://github.com/Nevers1/rekit rekit-emu`
- Optional external tools you may already have: `r2`, `jadx`, `apktool`,
Ghidra, IDA, `ilspycmd`, `binwalk`, `frida`, Chrome, Volatility 3. `doctor`
lists what is there, and everything else still works without them.
- No API keys, no accounts, no telemetry. Everything runs locally; `http` and
`browser` contact the network only at the URL you give them.
### Honest limits
- Emulation is function-level: it models one call, not the program's lifecycle.
- 32-bit ARM floating point (VFP/NEON) cannot be executed by the sandbox;
AArch64, x86-64 and PE are fine.
- A check that asks a server (licence, attestation) can only be answered on the
client half.
- It analyses; it does not unpack VMProtect or Themida.
### Who it is for
Security engineers and pentesters doing authorised assessment, incident
responders triaging a sample, mobile engineers working out what a third-party
SDK does, and developers who inherited a binary with no source.
Not a one-click cracker: this is a method plus a toolchain, and it expects the
target to be something you are allowed to analyse.
Requires local installs of analysis tools like Ghidra or r2. Emulation depends on sandbox models and won't perfectly replicate all syscalls or network-dependent checks.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 2 days ago
Requires
Permissions
File Scopes
Every tool acts only on the path the user passes in. No directory walking, no scanning, no background reads; `patch` writes to that same file and keeps a backup in the cache.