Skip to content
Back to search

claude-pentest

SkillWorks with Claude CodeGitHub

An open source plugin for enabeling claude to gain offensive pentesting capabilities

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/stickman230--claude-pentest/badge.svg)](/listings/stickman230--claude-pentest)

HTML

<a href="/listings/stickman230--claude-pentest"><img src="/api/listings/stickman230--claude-pentest/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.

First Add Marketplace

# Add marketplace from inside claude code
/plugin marketplace add Stickman230/claude-pentest

Then Install plugin

# Install plugin from inside claude code
/plugin install pentest@claude-pentest

The plugin installs into your project's `.claude/` directory. Once installed, all agents, skills, and slash commands are available in any Claude Code session.

Optional: Kali Server (MKS)

For server-side testing (nmap, sqlmap, gobuster, Metasploit, etc.), the plugin can connect to a remote Kali Linux REST API. Without it, agents fall back to whatever tools are available locally via Bash.

**Setup:** Deploy [MCP-Kali-Server](https://github.com/Wh0am123/MCP-Kali-Server) on a Kali Linux host reachable from your machine, then run `/pentest:pentest-kali` in Claude Code to connect and save the configuration. The server URL and tool availability are written to `.pentest-mks.json` and picked up automatically at engagement launch.

---

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.

.claude-plugin/marketplace.json · Manifest · 23 lines

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

  1. {
  2. "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
  3. "name": "claude-pentest",
  4. "description": "Claude Code plugins for authorized security testing, AI threat testing, and reconnaissance",
  5. "owner": {
  6. "name": "Stickman230",
  7. "email": "maxime.reynaud230@gmail.com"
  8. },
  9. "plugins": [
  10. {
  11. "name": "pentest",
  12. "source": "./plugins/pentest",
  13. "description": "Full penetration testing framework - 63 attack categories across 11 domains covering OWASP, injection, authentication, cloud, and more",
  14. "version": "2.2.6",
  15. "author": {
  16. "name": "Stickman230",
  17. "url": "https://github.com/Stickman230"
  18. },
  19. "category": "security",
  20. "strict": false
  21. }
  22. ]
  23. }
README.md · README · 661 lines

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

  1. <p align="center">
  2. <h1 align="center">claude-pentest</h1>
  3. <p align="center">
  4. A full penetration testing framework for Claude Code with Kali MCP integration containing 15 agents, 6 skill coordinators and 63 attack categories.
  5. <br />
  6. Structured, human-in-the-loop, evidence-driven.
  7. </p>
  8. <p align="center">
  9. <a href="https://github.com/Stickman230/claude-pentest/blob/main/LICENSE">
  10. <img src="https://img.shields.io/github/license/Stickman230/claude-pentest?style=flat-square" alt="License" />
  11. </a>
  12. <a href="https://github.com/Stickman230/claude-pentest/stargazers">
  13. <img src="https://img.shields.io/github/stars/Stickman230/claude-pentest?style=flat-square&color=yellow" alt="Stars" />
  14. </a>
  15. <a href="https://github.com/Stickman230/claude-pentest/network/members">
  16. <img src="https://img.shields.io/github/forks/Stickman230/claude-pentest?style=flat-square" alt="Forks" />
  17. </a>
  18. <a href="https://github.com/Stickman230/claude-pentest/issues">
  19. <img src="https://img.shields.io/github/issues/Stickman230/claude-pentest?style=flat-square" alt="Issues" />
  20. </a>
  21. <img src="https://img.shields.io/badge/Claude_Code-compatible-6B46C1?style=flat-square&logo=anthropic" alt="Claude Code compatible" />
  22. <img src="https://img.shields.io/badge/agents-15-0EA5E9?style=flat-square" alt="15 agents" />
  23. <img src="https://img.shields.io/badge/attack_categories-63-EF4444?style=flat-square" alt="63 attack categories" />
  24. <img src="https://img.shields.io/badge/authorized_use_only-red?style=flat-square" alt="Authorized use only" />
  25. </p>
  26. <p align="center">
  27. <a href="README.md"><strong>English</strong></a> | <a href="README.zh-CN.md">简体中文</a> | <a href="README.fr.md">Français</a>
  28. </p>
  29. </p>
  30. ---
  31. > **For authorized security testing only.** Always obtain written permission before testing any system you do not own.
  32. ---
  33. ## What this is
  34. `claude-pentest` is a Claude Code plugin that gives Claude structured penetration testing capabilities. It is not a script or scanner, it is an **agent coordination framework**: the `/pentest:pentest` command coordinates the engagement from the main session — it runs reconnaissance, asks a planner agent for a deployment plan, then deploys specialized executor agents (each following a strict 4-phase workflow) in parallel, spending the time budget on escalation, and requiring operator approval before any active exploitation begins. Every finding ships with a working PoC, captured HTTP evidence, and a Playwright screenshot.
  35. **Key principles:**
  36. - Human-in-the-loop at every escalation point — Claude cannot proceed to exploitation without your confirmation
  37. - Evidence-first — no theoretical findings, only verified PoCs with `poc.py` and `poc_output.txt`
  38. - Structured outputs — every engagement writes machine-readable JSON + markdown analysis to `outputs/{engagement}/`
  39. - Breadth — 11 attack domains, 63 sub-categories, 25+ security tools referenced
  40. ---
  41. ## Install
  42. First Add Marketplace
  43. ```bash
  44. # Add marketplace from inside claude code
  45. /plugin marketplace add Stickman230/claude-pentest
  46. ```
  47. Then Install plugin
  48. ```bash
  49. # Install plugin from inside claude code
  50. /plugin install pentest@claude-pentest
  51. ```
  52. The plugin installs into your project's `.claude/` directory. Once installed, all agents, skills, and slash commands are available in any Claude Code session.
  53. ### Optional: Kali Server (MKS)
  54. For server-side testing (nmap, sqlmap, gobuster, Metasploit, etc.), the plugin can connect to a remote Kali Linux REST API. Without it, agents fall back to whatever tools are available locally via Bash.
  55. **Setup:** Deploy [MCP-Kali-Server](https://github.com/Wh0am123/MCP-Kali-Server) on a Kali Linux host reachable from your machine, then run `/pentest:pentest-kali` in Claude Code to connect and save the configuration. The server URL and tool availability are written to `.pentest-mks.json` and picked up automatically at engagement launch.
  56. ---
  57. ## Quick Start
  58. The recommended way to start an engagement is via the guided slash command:
  59. ```
  60. /pentest:pentest
  61. ```
  62. This walks you through scope collection, attack profile selection, optional Kali server configuration, then runs the engagement itself (pre-flight → recon → planning → executor deployment → time-budget loop → report). See [Slash Commands](#slash-commands) below for the full command reference.
  63. ---
  64. ## Slash Commands
  65. Five slash commands are included for guided session management. They are auto-discovered by Claude Code and invoked by name.
  66. ### /pentest:pentest
  67. **Purpose:** Guided engagement launcher *and* orchestrator — collects scope, attack profile, and Kali server configuration, then runs the engagement from the main session (the command owns dispatch because the harness allows only one level of subagent nesting).
  68. **Flow:**
  69. 1. Displays ASCII art banner
  70. 2. Asks whether to isolate the session to the pentest plugin (recommended — prevents other plugins interfering with the engagement)
  71. 3. Checks for a saved scope (`.pentest-scope.json`) — if found, offers to reuse it or enter new scope. Collects the scope fields if entering new scope: target, engagement name, out-of-scope restrictions, time budget (the quota the engagement spends), authentication credentials, thoroughness level (Light / Medium / Deep / Full), and deliverable formats. Target, scope, auth, and time budget are free-text prompts; thoroughness and deliverable formats are multiple choice
  72. 4. Checks for a saved attack profile (`.pentest-attacks.json`) — if found, offers to use it or run the full suite. If no profile is found, offers inline mode selection (Full / Web app / API & cloud / Custom)
  73. 5. Checks for a configured Kali server (`.pentest-mks.json`) — if active, displays tool availability and asks whether to use MKS endpoints; if none is configured, offers to connect one inline (URL prompt + `/health` check) so you don't have to run a separate command and relaunch
  74. 6. Outputs an engagement summary for review
  75. 7. Runs the engagement from the main session: pre-flight reachability check → dispatches recon agents → invokes the `pentester-orchestrator` planner for a deployment plan → presents the plan for approval → deploys the specialized executor agents in parallel → time-budget quota loop (escalation) → aggregates → writes `pentest-report.json` + `report.md`
  76. **Isolation note:** If isolation is selected in step 2, Claude constrains itself to pentest plugin agents and skills for the duration of the session. This constraint is lifted when `/pentest:pentest-exit` runs or `/clear` resets the context.
  77. ---
  78. ### /pentest:pentest-scope
  79. **Purpose:** Define or update engagement scope without launching a pentest. Useful for preparing scope ahead of time or updating scope mid-engagement.
  80. **Flow:**
  81. 1. Reads any existing `.pentest-scope.json` and displays current scope if found
  82. 2. If an existing scope is found: offers update or cancel; detects drastic vs minor target changes when an engagement is active (drastic change = different domain or IP subnet triggers a warning with options)
  83. 3. Collects the scope fields in sequence (free-text for target/scope/auth/time budget; multiple choice for thoroughness and deliverable formats)
  84. 4. Writes `.pentest-scope.json` with `status: pending`
  85. 5. Displays a confirmation block with next steps
  86. ---
  87. ### /pentest:pentest-attacks
  88. **Purpose:** Define which attack categories the engagement should cover, without launching a pentest. Saves the profile for reuse across sessions.
  89. **Flow:**
  90. 1. Reads any existing `.pentest-attacks.json` and displays it if found; offers update or keep
  91. 2. Mode selection: Full suite / Web application profile / API & cloud profile / Custom
  92. 3. Custom mode: three multi-select questions covering all 12 attack categories — each selection maps to the correct skill coordinator and executor agent(s)
  93. 4. Writes `.pentest-attacks.json`
  94. 5. Displays a confirmation block
  95. **Presets:**
  96. - **Web app** — injection, client-side, server-side, authentication, API security, business logic
  97. - **API & cloud** — API security, cloud & containers, IP infrastructure, CVE testing, domain recon
  98. ---
  99. ### /pentest:pentest-kali
  100. **Purpose:** Connect a remote Metasploit-Kali Server (MKS) REST API (see [Kali MCP](https://github.com/Wh0am123/MCP-Kali-Server)) and configure agents to prefer its endpoints over local Bash equivalents.
  101. **Flow:**
  102. 1. Asks for the MKS server URL (e.g., `http://192.168.1.10:5000`)
  103. 2. Verifies connectivity via `/health` endpoint
  104. 3. Parses and displays tool availability: nmap, gobuster, dirb, nikto (verified), sqlmap, hydra, john, metasploit (assumed)
  105. 4. Writes `.pentest-mks.json` with `status: active`
  106. 5. Displays the active MKS session block with curl usage examples for each tool
  107. When MKS is active, the time-budget loop runs **post-exploitation** if a CVE or RCE finding is confirmed — deploying Metasploit via the MKS endpoint. It never runs speculatively.
  108. ---
  109. ### /pentest:pentest-exit
  110. **Purpose:** Structured session close — reads findings, flushes unsaved notes, outputs a severity-bucketed summary, resets session state, and lifts the isolation constraint.
  111. **Flow:**
  112. 1. Asks for the engagement name (used as the `outputs/{name}/` folder)
  113. 2. Reads findings from `outputs/{name}/findings/` (Schema A) or `outputs/{name}/processed/findings/` (Schema B) — whichever the engagement used
  114. 3. Flushes any unsaved in-progress notes or findings to disk
  115. 4. Outputs severity-bucketed session summary (Critical / High / Medium / Low / Info counts + top 3 findings)
  116. 5. Outputs an isolation lift instruction block
  117. 6. Resets both `.pentest-scope.json` and `.pentest-attacks.json` to `status: pending` — a subsequent `/pentest:pentest` will offer to reuse them rather than assuming they are still active
  118. 7. Prompts to run `/clear` to fully reset the context window before the next engagement
  119. **Note:** Engagement outputs remain in `outputs/{name}/` after `/clear`.
  120. ---
  121. ## Session State Files
  122. Three JSON files persist session configuration at the project root. They decouple preparation from launch — you can define scope, attack profile, and Kali server connection independently, then launch when ready.
  123. | File | Written by | Purpose |
  124. |------|-----------|---------|
  125. | `.pentest-scope.json` | `/pentest:pentest-scope`, `/pentest:pentest` | Target, engagement name, out-of-scope, auth, timing (time budget/quota), thoroughness, output_formats, and `status: pending\|active` |
  126. | `.pentest-attacks.json` | `/pentest:pentest-attacks`, `/pentest:pentest` | Attack mode and selected categories with skill/executor mapping, and `status: pending\|active` |
  127. | `.pentest-mks.json` | `/pentest:pentest-kali` | Kali server URL, essential tool availability flags, and `status: active` |
  128. ### Lifecycle
  129. ```
  130. /pentest:pentest-scope → writes .pentest-scope.json (status: pending)
  131. /pentest:pentest-attacks → writes .pentest-attacks.json (status: pending)
  132. /pentest:pentest-kali → writes .pentest-mks.json (status: active)
  133. ↓
  134. /pentest:pentest reads all three files at launch:
  135. • scope found → offers reuse or new scope; sets status: active on confirm
  136. • attacks found → offers reuse or full suite
  137. • MKS found → offers MKS tools or skip; carries mks_active into the engagement
  138. ↓
  139. The command runs the engagement: pre-flight → recon → planner → approval →
  140. executor deployment → time-budget loop → report. Scope and MKS are already resolved.
  141. ↓
  142. /pentest:pentest-exit resets scope and attacks to status: pending.
  143. .pentest-mks.json is left active (server connection persists across engagements).
  144. ```
  145. ### Typical workflows
  146. **Prepare ahead, launch when ready:**
  147. ```
  148. /pentest:pentest-scope # define scope
  149. /pentest:pentest-attacks # define attack profile
  150. /pentest:pentest-kali # connect Kali server (optional)
  151. /pentest:pentest # launch — all three are detected and offered for reuse
  152. ```
  153. **Quick launch (no pre-configuration):**
  154. ```
  155. /pentest:pentest # collects scope inline, offers attack mode, checks for MKS
  156. ```
  157. **Reuse across engagements:**
  158. After `/pentest:pentest-exit`, `.pentest-scope.json` and `.pentest-attacks.json` are reset to `status: pending`. The next `/pentest:pentest` will detect them and offer reuse — useful when re-testing the same target with the same attack profile. Edit the scope fields as needed via `/pentest:pentest-scope` before relaunching.
  159. ---
  160. ## Architecture
  161. ```mermaid
  162. graph TD
  163. User["👤 Operator"] --> CMD["⌨️ /pentest:pentest command<br/>(owns orchestration)"]
  164. CMD --> PLAN["🎯 pentester-orchestrator<br/>(planner — returns a plan)"]
  165. PLAN -.deployment plan.-> CMD
  166. CMD --> WAM["🗺️ web-application-mapping"]
  167. CMD --> CAP["🛡️ common-appsec-patterns"]
  168. CMD --> CVE["🔍 cve-testing"]
  169. CMD --> DOM["🌐 domain-assessment"]
  170. CMD --> PKI["🗡️ pentest (main index)"]
  171. CMD --> AUTH["🔐 authenticating"]
  172. CMD --> PATT["📦 patt-fetcher"]
  173. WAM --> SC["inventory-software-catalog"]
  174. WAM --> DS["inventory-directory-scanner"]
  175. WAM --> AD["inventory-api-discovery"]
  176. WAM --> JM["inventory-javascript-mapper"]
  177. WAM --> SA["inventory-surface-analyzer"]
  178. CAP --> XSS["xss-tester"]
  179. CAP --> CSRF["csrf-tester"]
  180. CAP --> INJ["injection-tester"]
  181. CAP --> CSP["csp-bypass-tester"]
  182. CAP --> PP["prototype-pollution-tester"]
  183. CVE --> CVET["cve-tester"]
  184. DOM --> DOMT["domain-assessment"]
  185. PKI --> EXEC["pentester-executor"]
  186. SC --> OUT["📁 outputs/{engagement}/"]
  187. DS --> OUT
  188. AD --> OUT
  189. JM --> OUT
  190. SA --> OUT
  191. XSS --> OUT
  192. CSRF --> OUT
  193. INJ --> OUT
  194. CSP --> OUT
  195. PP --> OUT
  196. CVET --> OUT
  197. DOMT --> OUT
  198. EXEC --> OUT
  199. style CMD fill:#7C3AED,color:#fff
  200. style PLAN fill:#4C1D95,color:#fff
  201. style WAM fill:#1D4ED8,color:#fff
  202. style CAP fill:#1D4ED8,color:#fff
  203. style CVE fill:#1D4ED8,color:#fff
  204. style DOM fill:#1D4ED8,color:#fff
  205. style PKI fill:#1D4ED8,color:#fff
  206. style AUTH fill:#1D4ED8,color:#fff
  207. style OUT fill:#065F46,color:#fff
  208. ```
  209. ---
  210. ## Engagement Lifecycle
  211. ```mermaid
  212. flowchart LR
  213. P1["6.1 Init\n(time quota)"]
  214. P2["6.2 Pre-flight\n(reachability)"]
  215. P3["6.3 Recon\n& Inventory"]
  216. P4["6.4 Planning\n(planner agent)"]
  217. GATE1{{"✋ Operator\nApproval"}}
  218. P5["6.5 Executor\nDeployment"]
  219. P6["6.6 Quota loop\n(escalation)"]
  220. P7["6.7 Aggregate"]
  221. GATE2{{"✋ Operator\nConfirmation"}}
  222. P8["Report\njson + report.md"]
  223. P1 --> P2
  224. P2 -->|"reachable"| P3
  225. P3 -->|"inventory\ncomplete"| P4
  226. P4 --> GATE1
  227. GATE1 -->|"Approved"| P5
  228. GATE1 -->|"Modify"| P4
  229. P5 --> P6
  230. P6 -->|"quota spent /\nsurface exhausted"| P7
  231. P7 --> GATE2
  232. GATE2 -->|"Confirmed"| P8
  233. style GATE1 fill:#DC2626,color:#fff
  234. style GATE2 fill:#DC2626,color:#fff
  235. style P2 fill:#374151,color:#fff
  236. style P6 fill:#92400E,color:#fff
  237. style P8 fill:#065F46,color:#fff
  238. ```
  239. The `/pentest:pentest` command runs these steps itself (the harness allows only one level of subagent nesting, so the command — not an agent — dispatches the executors). The `pentester-orchestrator` agent is a **planner**: at step 6.4 it reads scope + recon and returns a deployment plan, which the command presents for approval and then executes.
  240. **Pre-flight (6.2)** aborts early with an actionable message if the target is unreachable, before any executor is deployed.
  241. **The time budget is a quota, not a ceiling (6.6)** — after the first wave, the command spends remaining budget escalating (authenticated re-test, vulnerability chaining, confirming unconfirmed findings with the right tool, broader payloads). Finishing early requires a logged "surface exhausted" justification.
  242. **Post-exploitation** runs inside the quota loop only when both a Kali server is connected (`.pentest-mks.json` active) and at least one finding confirms a CVE or RCE. It is never run speculatively.
  243. Within each executor agent, a second approval gate exists between **Phase 2 (Experiment — safe probes only)** and **Phase 3 (Test — active exploitation)**. The executor presents its candidate vectors and waits for explicit confirmation before proceeding.
  244. ---
  245. ## Target-Type Routing
  246. | Target | Entry-point skill coordinator | Notes |
  247. |--------|-------------------------------|-------|
  248. | Web application | `web-application-mapping` → `common-appsec-patterns` | Start with full inventory |
  249. | REST / GraphQL API | `cve-testing` + `domain-assessment` | No browser surface |
  250. | Cloud infrastructure | `pentester-executor` → `attacks/cloud-containers/` | No dedicated coordinator — route through executor |
  251. | Network / IP | `pentest` → `attacks/ip-infrastructure/` | 9 sub-skills (port scanning, DNS, SMB, MITM…) |
  252. | Full-scope | All coordinators in sequence + `physical-social` (if authorized in writing) | Confirm written authorization |
  253. | Authentication-focused | `authenticating` | Uses Playwright MCP directly — no sub-executor |
  254. ---
  255. ## Agents
  256. ### Orchestrator
  257. | Agent | Description | Tools |
  258. |-------|-------------|-------|
  259. | `pentester-orchestrator` | **Planner.** Reads confirmed scope + recon and returns a deployment plan (`plan/deployment-plan.json` + `plan/test-plan.md`). Does not deploy agents — the `/pentest:pentest` command dispatches (one-level subagent-nesting constraint). | Read, Write, Bash, Glob, Grep |
  260. ### Executor Agents
  261. | Agent | Description | Tools |
  262. |-------|-------------|-------|
  263. | `pentester-executor` | General executor with 30+ attack specializations. Follows 4-phase workflow (Phase 0: mount skill → Recon → Experiment → approval gate → Test → Verify). | Playwright MCP, Bash, Read, Write |
  264. | `xss-tester` | Reflected, stored, DOM-based XSS. Covers framework sinks (React, Vue, Angular), WAF evasion, CSP bypass. Evidence via Playwright. | Playwright MCP, Bash, Read, Write |
  265. | `csrf-tester` | CSRF: missing tokens, SameSite bypass, token reuse, method override. Generates browser-loadable PoC HTML. | Bash, Read, Write |
  266. | `injection-tester` | SQLi, NoSQLi, OS command injection. Automated with sqlmap + manual curl probing. | Bash, Read, Write |
  267. | `csp-bypass-tester` | CSP header analysis + bypass vectors: unsafe-inline, wildcard sources, JSONP, Angular sandbox, open redirects. | Playwright MCP, Bash, Read, Write |
  268. | `prototype-pollution-tester` | Client-side prototype pollution via URL params, hash fragments, JSON. Verifies `Object.prototype` pollution in browser DOM. | Playwright MCP, Bash, Read, Write |
  269. | `cve-tester` | Identifies tech stacks, researches NVD/Exploit-DB/GitHub, adapts PoC exploits, validates exploitability live. | Bash, Read, Write, WebFetch, WebSearch |
  270. | `domain-assessment` | Subdomain discovery (subfinder, amass, crt.sh), port scanning (nmap, masscan), service enumeration. Builds attack surface inventory. | Bash, Read, Write, Edit |
  271. ### Inventory Agents
  272. | Agent | Description | Tools |
  273. |-------|-------------|-------|
  274. | `inventory-software-catalog` | Identifies all dependencies, frameworks, and versions. Generates SBOM and flags components with known CVEs. | Bash, Read, Write, WebFetch, WebSearch |
  275. | `inventory-directory-scanner` | Active directory/file brute-forcing: ffuf, gobuster, feroxbuster, nikto, dirsearch. Discovers admin panels, backups, config files. | Bash, Read, Write |
  276. | `inventory-api-discovery` | Discovers REST endpoints, GraphQL schemas, SOAP/WSDL, WebSockets, Swagger/OpenAPI/Postman docs. | Bash, Read, Write |
  277. | `inventory-javascript-mapper` | SPA route extraction via headless Playwright: React Router, Vue Router, Angular routes, AJAX endpoints invisible to static scanners. | Playwright MCP, Bash, Read, Write |
  278. | `inventory-surface-analyzer` | Synthesizes all four inventory agent outputs into a unified risk-tiered attack surface report + actionable testing checklist. Reads only — runs no scans. | Read, Write |
  279. ### Utility
  280. | Agent | Description | Model |
  281. |-------|-------------|-------|
  282. | `patt-fetcher` | On-demand PayloadsAllTheThings payload fetching. Input: category name. Output: relevant payloads from PATT GitHub. | Haiku (lightweight) |
  283. ---
  284. ## Skill Coordinators
  285. | Skill | Coverage | Executors |
  286. |-------|----------|-----------|
  287. | `web-application-mapping` | Passive browsing, active directory/API/JS discovery, surface synthesis | 5 inventory agents |
  288. | `common-appsec-patterns` | XSS, CSRF, SQLi/NoSQLi/CMDi, CSP bypass, prototype pollution | 5 specialized testers |
  289. | `cve-testing` | Tech stack fingerprinting, CVE research, PoC adaptation, live validation | cve-tester |
  290. | `domain-assessment` | Subdomain enumeration, cert transparency, DNS brute-force, port scanning | domain-assessment |
  291. | `pentest` | Master attack index — 11 domains, 63 sub-categories. Routes executor to specific attack sub-skills | pentester-executor |
  292. | `authenticating` | Signup/login automation, 2FA/OTP bypass, CAPTCHA evasion, OAuth flows | Direct Playwright MCP (no sub-executor) |
  293. ---
  294. ## Attack Coverage
  295. <details>
  296. <summary><strong>Injection (9)</strong> — SQLi, NoSQLi, CMDi, SSTI, XXE, LDAP, SAML, Type Juggling, File Inclusion</summary>
  297. | Sub-category | Techniques |
  298. |-------------|-----------|
  299. | `sql-injection` | Error-based, blind, time-based, UNION, sqlmap automation |
  300. | `nosql-injection` | MongoDB operator injection (`$where`, `$regex`), regex injection |
  301. | `command-injection` | Unix/Windows CMDi, time-based blind, OOB DNS exfiltration |
  302. | `ssti` | Server-Side Template Injection (Jinja2, Twig, Smarty, FreeMarker) |
  303. | `xxe` | XML External Entity — file read, SSRF, blind OOB |
  304. | `ldap-injection` | LDAP filter injection |
  305. | `saml-injection` | SAML response manipulation, signature wrapping |
  306. | `type-juggling` | PHP loose comparison exploitation |
  307. | `file-inclusion` | LFI/RFI, PHP wrappers, log poisoning, path-to-inclusion |
  308. </details>
  309. <details>
  310. <summary><strong>Client-Side (6)</strong> — XSS, CSRF, DOM-based, Prototype Pollution, CORS, Clickjacking</summary>
  311. | Sub-category | Techniques |
  312. |-------------|-----------|
  313. | `xss` | Reflected, stored, DOM-based; React/Vue/Angular sinks; WAF evasion; CSP bypass |
  314. | `csrf` | Missing tokens, weak validation, SameSite bypass, method override, token reuse |
  315. | `dom-based` | DOM XSS via source-to-sink analysis |
  316. | `prototype-pollution` | URL params, hash fragments, JSON body; `Object.prototype` verification |
  317. | `cors` | CORS misconfiguration, credential leakage, null origin bypass |
  318. | `clickjacking` | iframe embedding, X-Frame-Options bypass, UI redressing |
  319. </details>
  320. <details>
  321. <summary><strong>Server-Side (6)</strong> — SSRF, HTTP Smuggling, Path Traversal, File Upload, Deserialization, Host Header</summary>
  322. | Sub-category | Techniques |
  323. |-------------|-----------|
  324. | `ssrf` | Internal service access, cloud metadata (169.254.169.254), blind SSRF via DNS |
  325. | `http-smuggling` | CL.TE, TE.CL, TE.TE variants; request queue poisoning |
  326. | `path-traversal` | `../` encoding variants, null bytes, Windows path separators |
  327. | `file-upload` | Extension bypass, MIME type spoofing, polyglot files, webshell upload |
  328. | `deserialization` | Java/PHP/Python insecure deserialization, gadget chains |
  329. | `host-header` | Host header injection, password reset poisoning, cache poisoning via Host |
  330. </details>
  331. <details>
  332. <summary><strong>Authentication (4)</strong> — Auth Bypass, JWT, OAuth, Password Attacks</summary>
  333. | Sub-category | Techniques |
  334. |-------------|-----------|
  335. | `auth-bypass` | Logic flaws, parameter manipulation, forced browsing, response tampering |
  336. | `jwt` | alg:none attack, weak secret brute-force, key confusion (RS256→HS256) |
  337. | `oauth` | Authorization code interception, state fixation, open redirect to token leakage |
  338. | `password-attacks` | Credential stuffing, brute force, password spraying, default credentials |
  339. </details>
  340. <details>
  341. <summary><strong>API Security (4)</strong> — GraphQL, REST API, WebSockets, Web LLM</summary>
  342. | Sub-category | Techniques |
  343. |-------------|-----------|
  344. | `graphql` | Introspection abuse, field suggestion enumeration, deeply nested query DoS, batching attacks |
  345. | `rest-api` | BOLA/IDOR, mass assignment, broken function-level authorization, API versioning exposure |
  346. | `websockets` | Cross-site WebSocket hijacking, message manipulation, auth bypass |
  347. | `web-llm` | Prompt injection via web inputs, indirect prompt injection, LLM API abuse |
  348. </details>
  349. <details>
  350. <summary><strong>Web Applications (9)</strong> — Access Control, Business Logic, Cache Attacks, Info Disclosure, Race Conditions, and more</summary>
  351. | Sub-category | Techniques |
  352. |-------------|-----------|
  353. | `access-control` | Horizontal/vertical privilege escalation, IDOR, parameter tampering |
  354. | `business-logic` | Multi-step flow manipulation, price tampering, workflow bypass |
  355. | `cache-deception` | Web cache deception via path confusion |
  356. | `cache-poisoning` | Cache poisoning via unkeyed headers, fat GET, host override |
  357. | `info-disclosure` | Source maps, debug pages, error stack traces, version headers |
  358. | `mass-assignment` | Binding attack on JSON/form fields not intended for user input |
  359. | `open-redirect` | URL parameter redirect, header-based redirect, OAuth redirect abuse |
  360. | `race-conditions` | TOCTOU, single-use token reuse, concurrent request exploitation |
  361. | `oauth-misconfig` | (see Authentication → oauth) |
  362. </details>
  363. <details>
  364. <summary><strong>Cloud & Containers (5)</strong> — AWS, Azure, GCP, Docker, Kubernetes</summary>
  365. | Sub-category | Techniques |
  366. |-------------|-----------|
  367. | `aws` | S3 bucket enumeration, IAM privilege escalation, Lambda abuse, EC2 metadata SSRF |
  368. | `azure` | Storage account exposure, Azure AD misconfiguration, managed identity abuse |
  369. | `gcp` | GCS bucket exposure, service account key leakage, Cloud Run misconfiguration |
  370. | `docker` | Privileged container escape, exposed Docker socket, image layer secrets |
  371. | `kubernetes` | RBAC misconfiguration, service account token abuse, etcd exposure, namespace escape |
  372. </details>
  373. <details>
  374. <summary><strong>System / Post-Exploitation (8)</strong> — PrivEsc, Active Directory, Hash Cracking, Persistence, Pivoting, Evasion, Exploit Dev, Reverse Shells</summary>
  375. | Sub-category | Key tools |
  376. |-------------|-----------|
  377. | `privilege-escalation` | LinPEAS, WinPEAS, sudo -l abuse, SUID/SGID, token impersonation |
  378. | `active-directory` | BloodHound, Mimikatz, Kerberoasting, AS-REP roasting, Pass-the-Hash |
  379. | `hash-cracking` | hashcat (GPU), john the ripper, rainbow tables, rule-based attacks |
  380. | `persistence` | Cron jobs, registry run keys, startup folders, BITS jobs, WMI subscriptions |
  381. | `network-pivoting` | Chisel, SSH port forwarding, proxychains, Metasploit route |
  382. | `evasion` | AMSI bypass, AV signature evasion, PowerShell obfuscation, living-off-the-land |
  383. | `exploit-development` | GDB + pwndbg, pwntools, shellcode writing, ROP chain construction |
  384. | `reverse-shells` | bash, python, powershell, msfvenom — one-liners and staged payloads |
  385. </details>
  386. <details>
  387. <summary><strong>IP Infrastructure (8)</strong> — Port Scanning, DNS, SMB, MITM, Sniffing, DoS, VLAN, IPv6</summary>
  388. | Sub-category | Key tools |
  389. |-------------|-----------|
  390. | `port-scanning` | nmap (all scan types), masscan, service/version detection, NSE scripts |
  391. | `dns` | dnsrecon, dig, zone transfer (AXFR), DNS brute-force, PTR scanning |
  392. | `smb-netbios` | enum4linux, smbclient, null session enumeration, SMBv1 detection |
  393. | `mitm` | ARP spoofing, ettercap, Bettercap, SSL stripping |
  394. | `sniffing` | tcpdump, Wireshark, passive traffic capture and analysis |
  395. | `dos` | hping3, slowloris — authorized load testing only |
  396. | `vlan-hopping` | yersinia, 802.1Q double-tagging attack |
  397. | `ipv6` | IPv6 enumeration, rogue Router Advertisement, SLAAC attacks |
  398. </details>
  399. <details>
  400. <summary><strong>Physical & Social Engineering (1)</strong> — Phishing, Vishing, BEC, USB Baiting</summary>
  401. > Requires **explicit written authorization** from the client before any physical or social engineering activity.
  402. | Sub-category | Coverage |
  403. |-------------|---------|
  404. | `social-engineering` | Spear phishing (Gophish), pretexting, vishing, smishing, BEC, credential harvesting (Evilginx2), USB baiting |
  405. </details>
  406. <details>
  407. <summary><strong>Essential Skills (3)</strong> — Burp Suite, Methodology, Reporting</summary>
  408. | Sub-category | Coverage |
  409. |-------------|---------|
  410. | `burp-suite` | Proxy setup, scanner configuration, extensions (Active Scan++, Turbo Intruder) |
  411. | `methodology` | PTES, OWASP WSTG, MITRE ATT&CK mapping, engagement scoping |
  412. | `reporting` | Finding templates, CVSS scoring, executive summary, remediation writing |
  413. </details>
  414. ---
  415. ## Output Structure
  416. Every engagement writes structured outputs under `outputs/{engagement-name}/`:
  417. ```
  418. outputs/{engagement}/
  419. ├── activity/ # Per-agent NDJSON logs
  420. │ └── {agent-name}.log
  421. │
  422. ├── inventory/ # Structured JSON (inventory agents)
  423. │ ├── software-catalog.json # SBOM with CVE flags
  424. │ ├── directories.json
  425. │ ├── api-endpoints.json
  426. │ └── javascript-routes.json
  427. │
  428. ├── analysis/ # Markdown analysis (inventory agents)
  429. │ ├── software-catalog.md
  430. │ ├── attack-surface.md # Unified Tier 1–4 risk surface
  431. │ └── testing-checklist.md # Per-path actionable test list
  432. │
  433. ├── findings/ # Per-finding bundles (executor agents)
  434. │ └── finding-001/
  435. │ ├── description.md # Vuln, CVSS, CWE, impact, remediation
  436. │ ├── poc.py # Automated exploit (required)
  437. │ ├── poc_output.txt # Proof of execution (required)
  438. │ ├── workflow.md # Manual reproduction steps
  439. │ └── evidence/
  440. │ ├── request.txt
  441. │ ├── response.txt
  442. │ └── screenshot.png # Playwright capture (required)
  443. │
  444. └── pentest-report.json # Final machine-readable report
  445. ```
  446. **Finding format:**
  447. ```markdown
  448. # [Vulnerability Type] in [Location]
  449. **Severity**: Critical/High/Medium/Low
  450. **CVSS**: N.N (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N)
  451. ## Technical Details
  452. ## Business Impact
  453. ## Remediation
  454. ```
  455. ---
  456. ## Tools Reference
  457. | Category | Tools |
  458. |----------|-------|
  459. | Web scanning | ffuf, gobuster, feroxbuster, dirsearch, nikto, kiterunner, nuclei, dalfox |
  460. | Injection | sqlmap, curl |
  461. | Subdomain/DNS | subfinder, amass, dnsrecon, dig, crt.sh, httpx, waybackurls, gau |
  462. | Port scanning | nmap, masscan |
  463. | Browser automation | Playwright MCP (headless Chromium) |
  464. | CVE research | searchsploit (Exploit-DB), NVD JSON API, GitHub PoC search |
  465. | Post-exploitation | BloodHound, Mimikatz, hashcat, john, LinPEAS, WinPEAS, Chisel |
  466. | Social engineering | Gophish, Evilginx2 |
  467. | Payload source | PayloadsAllTheThings (via `patt-fetcher` agent) |
  468. ---
  469. ## Repository Structure
  470. ```
  471. claude-pentest/
  472. ├── .claude-plugin/
  473. │ └── marketplace.json # Marketplace listing (claude-pentest)
  474. ├── plugins/
  475. │ └── pentest/
  476. │ ├── .claude-plugin/
  477. │ │ └── plugin.json # Plugin metadata (MIT)
  478. │ ├── agents/ # 15 agent .md files
  479. │ ├── docs/
  480. │ │ ├── CLAUDE.md # Agent architecture overview
  481. │ │ ├── WORKFLOWS.md # Planning & approval workflow reference
  482. │ │ └── reference/
  483. │ │ ├── OUTPUT_STRUCTURE.md
  484. │ │ ├── REPORT_CONTRACT.md
  485. │ │ └── TEST_PLAN_FORMAT.md
  486. │ └── skills/
  487. │ ├── authenticating/
  488. │ ├── common-appsec-patterns/
  489. │ ├── cve-testing/
  490. │ ├── domain-assessment/
  491. │ ├── mks/ # Metasploit-Kali Server tool preferences
  492. │ ├── web-application-mapping/
  493. │ └── pentest/
  494. │ ├── SKILL.md # Main attack index
  495. │ └── attacks/ # 11 domains, 63 sub-categories
  496. ├── LICENSE
  497. └── README.md
  498. ```
  499. ---
  500. ## Legal
  501. This plugin is for **authorized security testing only**. Before using this plugin against any target:
  502. - Obtain **explicit written permission** from the system owner
  503. - Define scope in writing (Rules of Engagement)
  504. - For full-scope engagements, confirm physical/social engineering is explicitly authorized
  505. Misuse of this software to access systems without authorization is illegal. The authors are not responsible for unauthorized use.
  506. ---
  507. ## License
  508. MIT — see [LICENSE](LICENSE) for details.
  509. Copyright © Stickman230
  510. ---
  511. <p align="center">
  512. Built with <a href="https://claude.ai/code">Claude Code</a> · Published by <a href="https://github.com/Stickman230">Stickman230</a>
  513. </p>

Ratings and comments

Sign in to rate this skill.

Sign in

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