More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    rekit - Binary, APK & web Reverse Engineering

    1

    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

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    rekit - Binary, APK & web Reverse Engineering

    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
    1. rekit_info → ELF 64 little (x86-64), 16.0 KiB, 27 sections,
      sha256 276cdff4…1985bd

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

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

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

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

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Mobile Development.

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

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    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

    Accounts
    GitHub
    Software
    Githttps://github.com/Nevers1/rekit

    Install rekit first: cargo install --git https://github.com/Nevers1/rekit rekit-cli. Then run `rekit doctor` — it lists which of the optional tools (r2, jadx, Ghidra, Chrome) this machine has. Emulation needs the separate rekit-emu binary.

    Permissions

    Terminal / Shell
    Network Access
    Write Files
    Browser
    Read Files
    Environment Variables

    File Scopes

    Then
    explain
    in
    Notes
    because
    `**/*`
    looks
    broad
    and
    the
    reason
    is
    honest:
    user
    chooses
    file
    skill
    never
    goes
    looking
    on
    its
    own.

    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.

    Listed2 days ago

    What's inside

    Frequently Asked Questions

    Yes. The skill is the method; rekit is the engine. It is MIT-licensed and free, and installing it is one cargo command.

    Yes, except the `http` and `browser` tools, which contact the URL you give them.

    rekit is a Rust binary and builds on all three. Ghidra, jadx and Chrome work everywhere; the qemu engine needs an AArch64 sysroot.

    For targets you own or are engaged to assess. The instructions say so explicitly, and there is nothing here for scanning or attacking third parties.

    Free updates to this listing: new tools as rekit grows, new playbooks.

    New in Mobile Development