How to use the Android App Hooking for CTF agent skill

What the skill makes the agent do

The skill is a playbook for analysing an Android app's live trust boundary, meaning the point where the app decides what to send to the server and what the server accepts. Instead of relying only on strings found in the code, the agent is directed to choose the narrowest internal function to watch, such as a request signer or crypto helper, record its inputs and outputs with hooks, and rebuild the smallest request the server accepts.

The skill is an internal downstream skill. It is meant to run only after the parent skill ctf-sandbox-orchestrator has set up the sandbox assumptions and routed the task here. By default it replies in Simplified Chinese unless you ask for English.

• Maps the app's manifest, exported components, deeplinks, native libraries, shared prefs, local databases and bundled configs before hooking anything
• Prefers hooks on request signers, crypto helpers, keystore access, protobuf encode or decode, and JNI marshaling over broad UI hooks
• Covers SSL pinning, root checks and WebView bridges when they block the real request path
• Keeps hook logs, headers, nonces and storage paths tied to the same session so the result can be replayed

How to install the competition-android-hooking skill

Download the skill ZIP from this page. Then choose one of the two install routes below, depending on where you want the skill to be available.

For a personal setup, unzip the file into your ~/.claude/skills/ folder. For a single project, unzip it into that project's .claude/skills/ folder. In the Claude apps, you can instead upload the ZIP under Settings, then Capabilities, then Skills.

The package contains agents/openai.yaml, references/android-hooking.md and SKILL.md. Keep the folder structure intact so the agent can load the reference file.

• Personal install: unzip into ~/.claude/skills/
• Project install: unzip into the project's .claude/skills/
• Claude apps: Settings, then Capabilities, then Skills, then upload the ZIP

Requirements before you start

The skill assumes a working lab. It needs Frida and either a rooted Android device or an emulator, both inside a sandbox. It also needs an APK decompiler and manifest tools; the specific tools are named in the bundled reference file, so check that file for the exact list.

The parent skill ctf-sandbox-orchestrator must be installed and active. This skill depends on it and is not meant to be used on its own.

• Frida
• A rooted Android device or an emulator, inside a sandbox
• An APK decompiler and manifest tools (see references/android-hooking.md)
• The parent skill ctf-sandbox-orchestrator

How to trigger the skill with natural requests

The skill loads when your request matches its description. Ask for a specific Android task in plain language, and make sure the parent skill has already set up the sandbox. You can also name the parent skill explicitly, as its own description does.

Good triggers include asking the agent to hook an APK, inspect signer logic, trace Java or native boundaries, bypass pinning or root checks, inspect shared prefs or app databases, or replay accepted mobile requests. Vague requests such as fix my app are less likely to match.

• Hook the signer in this APK and log its input string and output signature
• Trace the JNI calls from this native library during login
• Find where the root check runs and show what the app does when it fails
• Look at the shared prefs and local database for the session token used in this challenge
• Replay the request the server accepted, using the same nonce and headers

Example workflow the skill follows

The skill works in three stages. First, static triage: it preserves the original APK and decompiled output before any patching, then maps exported components, deeplinks, prefs and databases. Second, it picks the narrowest runtime boundary to hook and records plaintext inputs, signed strings, headers and outputs there. Third, it rebuilds the smallest sequence that reaches the accepted server-side branch.

The agent is also told to correlate static and dynamic evidence before claiming it understands a trust edge. The reference file asks for three things kept together: where the code lives, what the hook or response proved, and which local state the result depends on.

• Static location: class, method, symbol or asset path
• Dynamic proof: hook log, returned value, request header or accepted response
• State dependency: token, database row, pref key, nonce or device flag

Safety notes: scripts and network

This skill runs scripts and uses the network, as stated in its requirements. Run it only inside an isolated lab that you control, not against live services or apps you do not own or have no authorisation to test. Bypassing pinning and root checks against live services can be illegal or harmful.

The skill also tells the agent to preserve the original APK before patching or resigning, which helps you go back to a clean state if something goes wrong.

• Use only isolated, controlled CTF sandboxes
• Do not target real apps or services without authorisation
• Keep the original APK, resources and decompiled output before patching
• Pure static string or crypto puzzles should go to a broader crypto or mobile skill instead

Tips for getting useful results

Give the agent the sandbox context up front, and let the parent skill finish its setup before asking for hooks. Name the feature or request you care about, such as a signer or login call, because the skill is built to narrow down to one boundary rather than hook everything.

If the challenge turns out to be mostly about recovering a transform, the skill itself says to switch back to the broader crypto or mobile skill. Keep your evidence organised as the reference file suggests, so the final replay is easy to check.

• Let ctf-sandbox-orchestrator finish its setup first
• Name one target boundary, such as a signer, JNI call or login request
• Ask for the smallest replayable request, not the whole app
• Note which account or session state each log belongs to