Skip to content
Back to search

iOS-reverse-engineering-claude-skill

Claude Code skill that enables Claude to extract, analyze, reverse engineer iOS apps

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/incogbyte--ios-reverse-engineering-claude-skill/badge.svg)](/listings/incogbyte--ios-reverse-engineering-claude-skill)

HTML

<a href="/listings/incogbyte--ios-reverse-engineering-claude-skill"><img src="/api/listings/incogbyte--ios-reverse-engineering-claude-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

As a Claude Code Skill (Recommended)

Add this repository as a skill in your Claude Code project:

claude mcp add-skill ios-reverse-engineering https://github.com/incogbyte/iOS-claude-skill.git

Or clone and add locally:

git clone https://github.com/incogbyte/iOS-claude-skill.git

Then reference the skill directory in your Claude Code configuration.

Verify Dependencies

Once installed, Claude will automatically check and install dependencies when you first use the skill. You can also verify manually:

bash skills/ios-reverse-engineering/scripts/check-deps.sh

If anything is missing:

bash skills/ios-reverse-engineering/scripts/install-dep.sh <dependency>

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 · 295 lines

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

  1. # iOS Reverse Engineering Skill for Claude Code
  2. A comprehensive [Claude Code skill](https://docs.anthropic.com/en/docs/claude-code/skills) that enables Claude to extract, analyze, and reverse engineer iOS applications. It processes IPA files, .app bundles, Mach-O binaries, dynamic libraries, and frameworks — producing structured documentation of APIs, security findings, embedded secrets, SDK inventories, and protection assessments.
  3. ## Features
  4. - **IPA/App Extraction** — Unpack IPA archives and .app bundles, dump Objective-C/Swift class headers via `ipsw class-dump`, extract Info.plist, entitlements, embedded frameworks, and string constants
  5. - **API Endpoint Discovery** — Find HTTP endpoints across URLSession, Alamofire, Moya, AFNetworking, GraphQL, and WebSocket patterns
  6. - **Call Flow Tracing** — Follow execution paths from ViewControllers through ViewModels/Presenters down to the networking layer
  7. - **Security Auditing** — Scan for ATS exceptions, certificate pinning issues, weak crypto, keychain misuse, jailbreak detection, debug artifacts, insecure deserialization, XXE, and Zip Slip
  8. - **Cloud Credential Scanning** — Deep-scan for leaked API keys and secrets from Firebase, AWS, GCP, Azure, Stripe, Twilio, SendGrid, and more — with LLM-assisted risk classification
  9. - **Deep Binary Reversing** — Decompile functions, trace cross-references, and analyze crypto/auth/network code using radare2, rizin, or Ghidra headless
  10. - **SDK Fingerprinting** — Identify all embedded third-party SDKs, detect versions, and cross-reference with known CVEs
  11. - **Protection Detection** — Detect obfuscation tools, anti-debugging, dylib injection prevention, integrity checks, jailbreak detection, and FairPlay DRM encryption
  12. ## Requirements
  13. - **macOS** with Xcode Command Line Tools (provides `otool`, `strings`, `plutil`, `codesign`)
  14. - **[ipsw](https://github.com/blacktop/ipsw)** — Required. Provides class-dump and Mach-O analysis (`brew install blacktop/tap/ipsw`)
  15. - **[radare2](https://github.com/radareorg/radare2)** or **[rizin](https://github.com/rizinorg/rizin)** — Recommended for deep binary analysis
  16. - **[Ghidra](https://ghidra-sre.org/)** — Optional. Enables advanced headless decompilation with included Java scripts
  17. > Linux is supported for static analysis of already-extracted files only.
  18. The skill includes dependency check and auto-install scripts that handle setup automatically.
  19. ## Installation
  20. ### As a Claude Code Skill (Recommended)
  21. Add this repository as a skill in your Claude Code project:
  22. ```bash
  23. claude mcp add-skill ios-reverse-engineering https://github.com/incogbyte/iOS-claude-skill.git
  24. ```
  25. Or clone and add locally:
  26. ```bash
  27. git clone https://github.com/incogbyte/iOS-claude-skill.git
  28. ```
  29. Then reference the skill directory in your Claude Code configuration.
  30. ### Verify Dependencies
  31. Once installed, Claude will automatically check and install dependencies when you first use the skill. You can also verify manually:
  32. ```bash
  33. bash skills/ios-reverse-engineering/scripts/check-deps.sh
  34. ```
  35. If anything is missing:
  36. ```bash
  37. bash skills/ios-reverse-engineering/scripts/install-dep.sh <dependency>
  38. ```
  39. ## Usage
  40. ### Quick Start with the `/extract-ipa` Command
  41. The skill provides a user-invocable slash command for the most common workflow:
  42. ```
  43. /extract-ipa /path/to/MyApp.ipa
  44. ```
  45. This will:
  46. 1. Check and install required dependencies
  47. 2. Extract the IPA and dump class headers
  48. 3. Analyze the app structure (Info.plist, entitlements, frameworks, architecture pattern)
  49. 4. Present a summary and offer next steps
  50. ### Supported Input Formats
  51. | Format | Description |
  52. |---|---|
  53. | `.ipa` | iOS App Store package (ZIP archive containing `Payload/*.app`) |
  54. | `.app` | Application bundle directory |
  55. | Mach-O binary | Raw executable binary |
  56. | `.dylib` | Dynamic library |
  57. | `.framework` | Framework bundle |
  58. ### Extraction Options
  59. ```bash
  60. # Basic extraction
  61. /extract-ipa MyApp.ipa
  62. # Custom output directory
  63. /extract-ipa MyApp.ipa -o ./my-analysis
  64. # Skip class-dump (faster, metadata only)
  65. /extract-ipa MyApp.ipa --no-classdump
  66. # Extract specific architecture from fat binaries
  67. /extract-ipa MyApp.ipa --thin arm64
  68. # Demangle Swift symbols
  69. /extract-ipa MyApp.ipa --swift-demangle
  70. ```
  71. ### Analysis Phases
  72. After extraction, you can ask Claude to perform any of the following analyses. Each phase builds on the extracted output.
  73. #### 1. Structure Analysis
  74. > "Analyze the app structure"
  75. Reads Info.plist, entitlements, class-dump output, and embedded frameworks. Identifies the architecture pattern (MVC, MVVM, VIPER, Coordinator) and key classes.
  76. #### 2. Call Flow Tracing
  77. > "Trace the login flow from the UI to the network layer"
  78. Follows execution paths: ViewController -> ViewModel/Presenter -> Service/Repository -> API Client -> URLSession/Alamofire. Maps dependency injection and service creation patterns.
  79. #### 3. API Endpoint Extraction
  80. > "Find all API endpoints and document them"
  81. Searches for HTTP endpoints across all major networking libraries. Supports targeted searches:
  82. - `--urlsession` — URLSession patterns only
  83. - `--alamofire` — Alamofire/AFNetworking only
  84. - `--graphql` — GraphQL operations
  85. - `--websocket` — WebSocket connections
  86. - `--auth` — Authentication patterns
  87. - `--urls` — Hardcoded URLs
  88. - `--swift-concurrency` — Combine/async-await patterns
  89. - `--security` — Security-related patterns
  90. Produces structured documentation for each endpoint including method, path, parameters, headers, response type, and call chain.
  91. #### 4. Security Audit
  92. > "Run a security audit on this app"
  93. Scans for:
  94. - App Transport Security (ATS) exceptions
  95. - Disabled certificate pinning
  96. - Hardcoded secrets and API keys
  97. - Jailbreak detection mechanisms
  98. - Weak cryptography (MD5, ECB mode, hardcoded IVs)
  99. - Keychain misuse (`kSecAttrAccessibleAlways`)
  100. - Debug artifacts and staging URLs
  101. #### 5. Cloud Credential Scan
  102. > "Scan for leaked API keys and credentials"
  103. Deep-scans for credentials from 20+ cloud providers with targeted scan options:
  104. - `--firebase` / `--aws` / `--gcp` / `--azure` — Cloud providers
  105. - `--payments` — Stripe, PayPal, RevenueCat
  106. - `--messaging` — Twilio, SendGrid, Slack, OneSignal
  107. - `--analytics` — Sentry, Mixpanel, Amplitude, Segment
  108. - `--jwt` — JWT tokens
  109. - `--severity high` — Critical and high severity only
  110. Each finding is classified by the LLM: service type, client-safety assessment, blast radius, false positive likelihood, validation steps, and remediation.
  111. #### 6. Deep Binary Reversing
  112. > "Decompile the authentication functions"
  113. Uses radare2/rizin or Ghidra headless for binary-level analysis:
  114. - `--quick` — Functions + strings + imports only
  115. - `--secrets` — Focus on credential handling code
  116. - `--network` — Focus on networking code
  117. - `--crypto` — Focus on crypto implementations
  118. - `--auth` — Focus on authentication logic
  119. - `--decompile "sym.objc.AuthService.login"` — Decompile a specific function
  120. - `--decompile-pattern "auth\|login\|token"` — Decompile matching functions
  121. - `--xrefs "sym.imp.CCCrypt"` — Cross-references to a function
  122. - `--callgraph "sym.objc.NetworkManager.request"` — Call graph visualization
  123. - `--entropy` — Detect packing/encryption
  124. - `--tool ghidra` — Force Ghidra headless with Java analysis scripts
  125. Included Ghidra scripts:
  126. - `DecompileAllFunctions.java` — Full or security-targeted decompilation
  127. - `FindSecrets.java` — Credential and API key detection in decompiled code
  128. - `ExportAPICalls.java` — Network API symbol tracing
  129. - `ExportCryptoUsage.java` — Crypto function usage and weak pattern detection
  130. - `ExportStringXrefs.java` — String cross-references categorized by type
  131. #### 7. SDK Fingerprinting
  132. > "Identify all third-party SDKs"
  133. Detects embedded SDKs by framework names, linked libraries, class prefixes, SDK-specific strings, and symbols. Categories include: Networking, Analytics, Advertising, Authentication, Payments, Push Notifications, Maps, Social, Database, Cloud Storage, UI/UX, Security, Messaging, Crash Reporting, A/B Testing, Deep Linking, and AR/ML.
  134. Options:
  135. - `--check-cves` — Cross-reference detected SDK versions with known vulnerabilities
  136. - `--verbose` — Show match details
  137. - `--json` — JSON output for programmatic use
  138. #### 8. Protection Detection
  139. > "What protections does this app use?"
  140. Detects anti-tampering mechanisms and outputs a protection score (0-20):
  141. - `--obfuscation` — iXGuard, SwiftShield, OLLVM, Arxan, name obfuscation ratio, string encryption, control flow flattening
  142. - `--debugger` — ptrace, sysctl, timing checks, exception ports, SIGTRAP handlers
  143. - `--injection` — `__RESTRICT` segment, DYLD checks, library enumeration, Substrate/Frida detection
  144. - `--integrity` — Runtime code signing, binary hash checks, team ID verification, receipt validation
  145. - `--jailbreak` — File path checks, URL schemes, sandbox escape tests, environment variables
  146. - `--encryption` — FairPlay DRM detection
  147. | Score | Level |
  148. |---|---|
  149. | 15-20 | Heavily protected |
  150. | 10-14 | Well protected |
  151. | 5-9 | Moderately protected |
  152. | 1-4 | Lightly protected |
  153. | 0 | Unprotected |
  154. #### 9. Static Vulnerability Audit
  155. > "Audit this app for iOS vulnerability classes"
  156. Hunts vulnerability *patterns* (not API calls or credential values) across 14 categories, each finding tagged with Severity, Confidence, and FP-likelihood so you can triage signal strength instead of treating every match as confirmed:
  157. - `--storage` — UserDefaults secrets, weak Keychain accessibility, unencrypted local DBs, backup-exclusion absence, App-Group `UserDefaults` secret exposure
  158. - `--webview` — `UIWebView`, file/universal access flags, JS-bridge handlers, TLS-bypassing auth challenge handlers
  159. - `--deeplink` — custom URL schemes, tokens passed through deeplink callbacks, universal links
  160. - `--crypto` — ECB mode, non-CSPRNG for tokens, MD5/SHA1, hardcoded IV/salt
  161. - `--auth` — biometric bypass patterns, Sign in with Apple nonce absence
  162. - `--logging` — secrets logged via `print`/`NSLog`/`os_log`
  163. - `--network` — ATS exceptions, cleartext/insecure-WebSocket, custom trust bypass, third-party certificate-pinning misconfiguration (AFNetworking/TrustKit/Alamofire), permanently-persisted `URLCredential`
  164. - `--privacy` — IDFA without ATT, sensitive pasteboard use, screen-capture and app-switcher/background-snapshot leaks, `LSApplicationQueriesSchemes` fingerprinting, Apple privacy manifest checks
  165. - `--entitlements` — disabled library validation, app groups, shared keychain groups
  166. - `--debug` — debug-gated insecure behavior, staging/internal URLs
  167. - `--hardening` — Mach-O PIE / hardened-runtime flags
  168. - `--injection` — NSPredicate/NSExpression, KVC, NSSelectorFromString/performSelector, stringWithFormat
  169. - `--deserialization` — deprecated `NSKeyedUnarchiver`/`NSUnarchiver` APIs, missing `NSSecureCoding`
  170. - `--parsing` — XXE (`NSXMLParser`/libxml2), Zip Slip in archive extraction
  171. - `--all` — every category (default); `--severity LEVEL` filters by minimum severity; `--report FILE` exports Markdown
  172. ### Generating Reports
  173. Most analysis scripts support `--report <file.md>` to generate structured Markdown reports:
  174. ```
  175. "Extract the app, scan for secrets, fingerprint SDKs, detect protections, and generate reports for everything"
  176. ```
  177. ## Project Structure
  178. ```
  179. iOS-claude-skill/
  180. ├── commands/
  181. │ └── extract-ipa.md # /extract-ipa slash command definition
  182. ├── skills/
  183. │ └── ios-reverse-engineering/
  184. │ ├── SKILL.md # Main skill definition and workflow
  185. │ ├── scripts/
  186. │ │ ├── check-deps.sh # Dependency checker
  187. │ │ ├── install-dep.sh # Auto-installer for dependencies
  188. │ │ ├── extract-ipa.sh # IPA/app extraction and class-dump
  189. │ │ ├── find-api-calls.sh # API endpoint discovery
  190. │ │ ├── deep-secret-scan.sh # Cloud credential scanner
  191. │ │ ├── reversing-analyze.sh # Binary reversing with r2/Ghidra
  192. │ │ ├── detect-sdks.sh # SDK fingerprinting
  193. │ │ ├── detect-protections.sh# Protection detection
  194. │ │ ├── audit-vulnerabilities.sh # Static vulnerability audit (14 categories)
  195. │ │ ├── lib/
  196. │ │ │ └── plist.sh # Portable plist readers (macOS + Linux)
  197. │ │ └── ghidra/ # Ghidra headless Java scripts
  198. │ │ ├── DecompileAllFunctions.java
  199. │ │ ├── FindSecrets.java
  200. │ │ ├── ExportAPICalls.java
  201. │ │ ├── ExportCryptoUsage.java
  202. │ │ └── ExportStringXrefs.java
  203. │ └── references/
  204. │ ├── setup-guide.md # Tool installation guide
  205. │ ├── class-dump-usage.md # ipsw class-dump reference
  206. │ ├── api-extraction-patterns.md
  207. │ ├── call-flow-analysis.md
  208. │ ├── cloud-secrets-patterns.md
  209. │ ├── reversing-tools-guide.md
  210. │ ├── sdk-fingerprinting.md
  211. │ ├── anti-tampering-patterns.md
  212. │ └── vulnerability-patterns.md
  213. ├── LICENSE # Unlicense (public domain)
  214. └── README.md
  215. ```
  216. ## Use Cases
  217. - **Security research** — Audit iOS apps for vulnerabilities, leaked credentials, and weak crypto before responsible disclosure
  218. - **Penetration testing** — Map attack surfaces, identify API endpoints, and assess protections during authorized engagements
  219. - **CTF competitions** — Quickly extract and analyze iOS challenge binaries
  220. - **Competitive analysis** — Understand how other apps are built, what SDKs they use, and how they structure their APIs
  221. - **Compliance auditing** — Verify that apps meet security standards (ATS, cert pinning, keychain usage, data encryption)
  222. - **Incident response** — Rapidly assess a suspicious IPA for malicious behavior, data exfiltration, or embedded malware
  223. ## License
  224. This project is released into the public domain under the [Unlicense](https://unlicense.org). See [LICENSE](LICENSE) for details.

Ratings and comments

Sign in to rate this skill.

Sign in

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