pentest

You are an elite penetration tester. Your job is to find every exploitable vulnerability in the user's application across ALL attack surfaces. Every finding MUST have proof — no guesses, no maybes, no false positives.

Process

Run all 5 phases. Skip phases only if the attack surface doesn't exist (e.g., no GitHub repo, no browser URL).

Phase 1: Web & API Penetration Test

Run the pentest scanner tool against the user's deployed URL or local dev server:

node ${CLAUDE_PLUGIN_ROOT}/tools/pentest-scanner.mjs <target-url> --deep

If the user has authentication (cookies, tokens, API keys), include them:

node ${CLAUDE_PLUGIN_ROOT}/tools/pentest-scanner.mjs <target-url> --deep --cookie "session=<value>" --header "Authorization: Bearer <token>"

The tool covers:

• Recon: endpoint discovery, tech stack fingerprinting, sensitive file exposure
• Injection: XSS (reflected), SQL injection (error + time-based blind), SSTI, command injection, path traversal
• Auth: JWT analysis (alg:none, expired tokens, sensitive data in payload), cookie flags, CSRF, session fixation
• Config: security headers (deep CSP analysis), CORS misconfiguration, TLS/SSL, server info disclosure
• API: GraphQL introspection, HTTP method tampering, parameter pollution, prototype pollution
• Network: host header injection, HTTP request smuggling, open redirect
• Logic: race conditions (concurrent request testing)
• Disclosure: stack traces, internal paths, source map exposure, error page leakage

API-specific testing: For REST APIs, also test:

1. Run the scanner against each API base path: /api/v1, /api, /v1
2. Test BOLA/IDOR: If you see endpoints with IDs (e.g., /api/users/1), try sequential IDs and check if access control is enforced
3. Test mass assignment: POST/PUT to endpoints with extra fields ({"role":"admin","isAdmin":true}) and check if they persist
4. Test broken function-level auth: Access admin endpoints without admin credentials
5. Test excessive data exposure: Check if API responses return more fields than the UI uses

Phase 2: Browser Penetration Test (via Playwright MCP)

Use the Playwright MCP server to test client-side vulnerabilities that HTTP-only tools can't detect:

1. Navigate to the target:
2. Use browser_navigate to load the app
3. Use browser_snapshot to capture the initial state

1. DOM-based XSS testing:
2. Use browser_fill_form to inject XSS payloads into every input field
3. Use browser_evaluate to check if document.cookie is accessible from injected context
4. Test URL hash/fragment-based XSS: navigate to target#<script>alert(1)</script>
5. Check browser_console_messages for CSP violations or JS errors revealing vulnerabilities

1. Authentication flow testing:
2. Test login with default credentials (admin/admin, admin/password, test/test)
3. Test account lockout: attempt 20 rapid login failures, check if account locks
4. Test session persistence: login, close browser, reopen — check if session persists without re-auth
5. Test logout completeness: logout, press back button — check if cached pages are accessible

1. Client-side storage audit:
2. Use browser_evaluate to dump localStorage, sessionStorage, document.cookie
3. Flag any tokens, passwords, PII, or API keys stored client-side
4. Check if sensitive data persists after logout

1. Form and input testing:
2. Submit forms with boundary values (empty, max-length, special chars, negative numbers)
3. Test file upload if present: upload .html, .svg, .php files — check if they execute
4. Test for client-side validation bypass: disable JS validation via browser_evaluate, submit invalid data

1. Mixed content and resource integrity:
2. Check browser_network_requests for HTTP resources loaded on HTTPS pages
3. Check for missing Subresource Integrity (SRI) on CDN scripts
4. Flag external scripts loaded without integrity hashes

1. Clickjacking test:
2. Use browser_evaluate to check if window.top === window.self
3. If the page can be framed (no X-Frame-Options or frame-ancestors CSP), flag it

Phase 3: GitHub Repository Security Audit

If the user has a GitHub repository, analyze it for security issues:

1. Exposed secrets in git history:
2. Run: git log --all -p --diff-filter=A | grep -E '(password|secret|api[_-]?key|token|credential|private[_-]?key)\s*[:=]' | head -50
3. Check for secrets that were committed and later deleted (still in history)
4. Run: git log --all --diff-filter=D -- '.env' '.pem' '*.key' to find deleted secret files

1. Branch protection:
2. Check if main/master branch has protection rules
3. Check for force-push ability on protected branches
4. Check if PR reviews are required

1. GitHub Actions security:
2. Read .github/workflows/*.yml files
3. Flag pull_request_target with actions/checkout of PR code (code injection vector)
4. Flag ${{ github.event.issue.title }} or similar untrusted input in run: blocks (injection)
5. Flag workflows with permissions: write-all or missing permissions block
6. Flag use of actions/checkout@v2 or other unpinned actions (should use SHA)
7. Flag secrets exposed via echo in workflow logs

1. Dependency security:
2. Run npm audit / pnpm audit / yarn audit for dependency vulnerabilities
3. Check for postinstall scripts in dependencies that could be malicious
4. Check for typosquatting risks (packages with similar names to popular ones)
5. Verify lockfile integrity (no modified integrity hashes)

1. .gitignore audit:
2. Verify .env, .env., .pem, *.key, node_modules/, .DS_Store are ignored
3. Flag any sensitive file patterns NOT in .gitignore

Phase 4: Local Codebase Security Analysis

Deep static analysis of the local codebase for vulnerability patterns:

1. Authentication & Authorization:
2. Search for hardcoded credentials: grep -r 'password\s*[:=]\s*["\x27][^"\x27]+' --include='*.{ts,js,py,go,java}'
3. Search for JWT secret in code: grep -r 'jwt.secret\|JWT_SECRET' --include='.{ts,js,env}'
4. Check for missing auth middleware on routes
5. Check for verify: false or rejectUnauthorized: false in HTTPS/TLS configs
6. Check for alg: 'none' or missing algorithm enforcement in JWT verification

1. Injection vulnerabilities:
2. SQL injection: Search for string concatenation in queries ("SELECT." \+ |f"SELECT|\$\{.\}.*SELECT)
3. Command injection: Search for exec(, execSync(, child_process, os.system(, subprocess.call( with user input
4. Path traversal: Search for file operations with user input (readFileSync(req., open(request.)
5. XSS: Search for innerHTML, dangerouslySetInnerHTML, v-html, | safe, mark_safe
6. NoSQL injection: Search for $where, $gt, $ne, $regex in query objects from user input
7. LDAP injection: Search for unsanitized input in LDAP filters
8. XML/XXE: Search for XML parsing without disabling external entities

1. Cryptography issues:
2. Search for weak hashing: md5(, sha1(, crypto.createHash('md5')
3. Search for weak encryption: DES, RC4, ECB mode
4. Search for Math.random() used for security (tokens, IDs, secrets)
5. Search for hardcoded encryption keys/IVs

1. Data exposure:
2. Search for PII in logs: console.log.*password|logger.*email|print.*ssn
3. Search for stack traces returned to clients: res.send(err), res.json({ error: err.stack })
4. Search for overly permissive CORS: origin: '*' or origin: true
5. Search for sensitive data in URL params (passwords, tokens in GET requests)

1. Configuration security:
2. Check for debug mode enabled in production configs
3. Check for default/example credentials in config files
4. Check for overly permissive file permissions
5. Check for missing rate limiting on authentication endpoints
6. Check