How to use the Competition iOS Runtime agent skill

What an agent skill is and what this one does

An agent skill is a folder of instructions that an AI agent loads when a task matches the skill's description. This one is a playbook for iOS runtime work inside a CTF sandbox. It tells the agent to map the app's static files first, then hook the parts of the running app that decide whether a request is accepted.

The skill points the agent at specific targets: Info.plist, entitlements, URL schemes, universal links, embedded frameworks, Keychain access, request builders, crypto helpers, certificate and trust checks, and Objective-C or Swift methods that gate a branch. It asks the agent to keep static evidence and live hook output tied together before claiming it understands a trust path.

• Maps bundle structure, Info.plist, entitlements, URL schemes and app group paths
• Hooks request builders, crypto helpers, trust evaluators, Keychain reads and Objective-C selectors or Swift methods
• Traces request inputs, headers, nonces, signed strings and outputs
• Patches or bypasses pinning or environment checks only as far as needed to see the real request path
• Replays the smallest accepted request, token or branch that proves the behaviour

What you need before you install it

The skill's own description lists several requirements. Read them before you start, because the skill assumes they are already in place.

The parent skill ctf-sandbox-orchestrator must be installed and active, and it must already have established sandbox assumptions, node ownership and evidence priorities. The skill says to return to the parent first if that has not happened.

You also need an iOS IPA and access to a jailbroken or instrumented test device or simulator. The source implies this from the runtime hooking work but does not spell out the setup in detail. Frida is needed for the runtime hooking itself. The source does not give installation steps for Frida or the device, so follow the official documentation for those tools.

• ctf-sandbox-orchestrator installed and active
• An iOS IPA file for a challenge you are authorised to test
• A jailbroken or instrumented test device or simulator (implied, not detailed in the source)
• Frida for runtime hooking

How to install the skill

You can install the skill in one of two ways. Download the ZIP from the skill's page on this site and then either unzip it into your personal skills folder or into a project's skills folder, or upload it through the Claude apps.

For a personal install, unzip it into ~/.claude/skills/. For a single project, unzip it into the .claude/skills/ folder inside that project. In the Claude apps, open Settings, then Capabilities, then Skills, and upload the ZIP there.

The package contains SKILL.md, agents/openai.yaml and references/ios-runtime.md. SKILL.md holds the instructions and the trigger description. The reference file holds the hook targets, storage checklist and evidence checklist that the agent reads when it needs them.

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

How to trigger the skill with natural requests

You do not need a special command. The agent loads the skill when your request matches its description. Requests that name an IPA, runtime tracing, Keychain or plist state, pinning, deeplinks or replaying accepted requests are the most likely to match.

The skill is meant to run as a downstream step. Start the session with ctf-sandbox-orchestrator so the sandbox scope is set, then ask for the iOS work. By default the agent replies in Simplified Chinese unless you explicitly ask for English.

• Hook the Objective-C methods in this IPA that build the login request.
• Trace the Swift runtime behaviour of the signing function in this sandbox app.
• Inspect the Keychain items and plist values this app writes after login.
• Bypass the SSL pinning in this test app so I can see the request path.
• Analyse how this app handles the custom URL scheme and universal links.
• Replay the accepted request from the hook log using the same session state.

A worked example of the workflow

The skill follows a fixed order. First it preserves the original IPA, the extracted bundle and any decrypted or re-signed copy as separate artifacts. Then it reads static files such as Info.plist, entitlements and URL schemes before it adds broad runtime hooks.

Next it picks the narrowest boundary that can prove the behaviour, such as the signer or a Keychain accessor. It correlates that with live hook output, then reproduces the accepted request, token or gated branch with the smallest hook set. Throughout, it records bundle paths, plist keys, selectors, class names and header names so the result can be checked later.

• Keep the original IPA, extracted bundle and any re-signed copy as separate files
• Read Info.plist, entitlements, URL schemes and Keychain usage first
• Hook the narrowest boundary, such as a signer or trust evaluator
• Match static locations to hook output before drawing conclusions
• Rebuild the smallest stateful sequence and replay it

Safety notes: scripts and network access

The skill is marked as running scripts and using the network. Treat it as a tool that executes code against an app and talks to services, not as plain documentation. Only use it inside an authorised CTF sandbox or on your own test apps in an isolated lab.

The skill itself focuses on bypassing SSL pinning and replaying signed requests. The source says it is not meant for analysing real third-party apps or production services without authorisation. Keep the sandbox scope set by the parent skill, and do not point the workflow at systems you do not have permission to test.

• Use only in an authorised CTF sandbox or an isolated lab with your own test apps
• Do not point it at real third-party apps or production services without authorisation
• Check what the scripts run and where network calls go before you run them
• Keep the parent skill's scope and evidence rules active for the whole session

Tips for better results

Give the agent the exact IPA, challenge scope and what you are trying to prove. The skill asks for the smallest hook set that answers the question, so a narrow goal produces cleaner evidence than a broad one.

If the task turns into mostly transform or cryptography recovery rather than iOS runtime work, the skill says to switch back to a broader crypto or mobile skill. Keep hook logs, plist keys and local storage artifacts from the same session together, because the evidence is only useful when it matches the same account state.

• State the goal and the boundary you want to prove, such as the signer or the Keychain read
• Keep hook logs and storage artifacts from the same session
• Avoid broad UI-handler hooks; the skill warns they often miss the real signer or trust evaluator
• Switch to a crypto or mobile skill if the work is mainly transform recovery