@gpzhang2001/sharpkit-skills 0.2.1

package/skills/custom/source_aware_sast.md

@@ -0,0 +1,192 @@
+---
+name: source-aware-sast
+description: Practical source-aware SAST and AST playbook for semgrep, ast-grep, gitleaks, and trivy fs
+---
+
+# Source-Aware SAST Playbook
+
+Use this skill for source-heavy analysis where static and structural signals should guide dynamic testing.
+
+## Fast Start
+
+Run tools from repo root and store outputs in a dedicated artifact directory:
+
+```bash
+mkdir -p /workspace/.source-aware
+```
+
+## Baseline Coverage Bundle (Recommended)
+
+Run this baseline once per repository before deep narrowing:
+
+```bash
+ART=/workspace/.source-aware
+mkdir -p "$ART"
+
+semgrep scan --config p/default --config p/golang --config p/secrets \
+  --metrics=off --json --output "$ART/semgrep.json" .
+# Build deterministic AST targets from semgrep scope (no hardcoded path guessing)
+python3 - <<'PY'
+import json
+from pathlib import Path
+
+art = Path("/workspace/.source-aware")
+semgrep_json = art / "semgrep.json"
+targets_file = art / "sg-targets.txt"
+
+try:
+    data = json.loads(semgrep_json.read_text(encoding="utf-8"))
+except Exception:
+    targets_file.write_text("", encoding="utf-8")
+    raise
+
+scanned = data.get("paths", {}).get("scanned") or []
+if not scanned:
+    scanned = sorted(
+        {
+            r.get("path")
+            for r in data.get("results", [])
+            if isinstance(r, dict) and isinstance(r.get("path"), str) and r.get("path")
+        }
+    )
+
+bounded = scanned[:4000]
+targets_file.write_text("".join(f"{p}\n" for p in bounded), encoding="utf-8")
+print(f"sg-targets: {len(bounded)}")
+PY
+xargs -r -n 200 sg run --pattern '$F($$$ARGS)' --json=stream < "$ART/sg-targets.txt" \
+  > "$ART/ast-grep.json" 2> "$ART/ast-grep.log" || true
+gitleaks detect --source . --report-format json --report-path "$ART/gitleaks.json" || true
+trufflehog filesystem --no-update --json --no-verification . > "$ART/trufflehog.json" || true
+# Keep trivy focused on vuln/misconfig (secrets already covered above) and increase timeout for large repos
+trivy fs --scanners vuln,misconfig --timeout 30m --offline-scan \
+  --format json --output "$ART/trivy-fs.json" . || true
+```
+
+## Semgrep First Pass
+
+Use Semgrep as the default static triage pass:
+
+```bash
+# Preferred deterministic profile set (works with --metrics=off)
+semgrep scan --config p/default --config p/golang --config p/secrets \
+  --metrics=off --json --output /workspace/.source-aware/semgrep.json .
+
+# If you choose auto config, do not combine it with --metrics=off
+semgrep scan --config auto --json --output /workspace/.source-aware/semgrep-auto.json .
+```
+
+If diff scope is active, restrict to changed files first, then expand only when needed.
+
+## AST-Grep Structural Mapping
+
+Use `sg` for structure-aware code hunting:
+
+```bash
+# Ruleless structural pass over deterministic target list (no sgconfig.yml required)
+xargs -r -n 200 sg run --pattern '$F($$$ARGS)' --json=stream \
+  < /workspace/.source-aware/sg-targets.txt \
+  > /workspace/.source-aware/ast-grep.json 2> /workspace/.source-aware/ast-grep.log || true
+```
+
+Target high-value patterns such as:
+- missing auth checks near route handlers
+- dynamic command/query construction
+- unsafe deserialization or template execution paths
+- file and path operations influenced by user input
+
+## Tree-Sitter Assisted Repo Mapping
+
+Use tree-sitter CLI for syntax-aware parsing when grep-level mapping is noisy:
+
+```bash
+tree-sitter parse -q <file>
+```
+
+Use outputs to improve route/symbol/sink maps for subsequent targeted scans.
+
+## Cross-Component Semantic Mapping
+
+Pattern scanners find local sinks but often miss a security decision in one component followed by a different interpretation in another. For complex middleware, proxies, frameworks, and plugin systems:
+
+1. Identify shared request/context fields and every writer/reader.
+2. Order the readers and writers by lifecycle phase: parse, route, authenticate, rewrite, authorize, dispatch, render.
+3. Mark fields whose semantic type changes (URL/path, MIME/handler, alias/package, external/internal route).
+4. Trace normal, error, retry, subrequest, and internal-redirect paths separately.
+5. Compare the representation checked by security code with the representation consumed by the final sink.
+
+Load `semantic_confusion` when this graph reveals overloaded fields, multiple parsers, normalization steps, or protocol translation.
+
+## Resolution and Namespace Risks
+
+In repositories with developer tooling, plugins, templates, or package runners, inspect lookup order rather than only dependency versions:
+
+- command runners that fall back from local binaries or `PATH` to a public registry
+- scoped/private package names exposing unscoped binary or alias names
+- plugin, template, module, and autoload search paths writable by a lower-privileged actor
+- CI/composite actions and devcontainer/bootstrap scripts that transitively execute package commands
+- missing local artifacts that silently activate a remote or broader fallback
+
+Record candidate names and verify ownership/existence without claiming or publishing them. A namespace gap is reportable only when the target actually resolves or executes the attacker-contestable name under realistic conditions.
+
+For npm/JavaScript, distinguish the package name from the executable name and
+model the actual working directory, dependency tree, global bin directory,
+cache, and registry configuration. `load_skill(["npx_confusion"])` when a bare
+`npx`/`npm exec` command may fall back from a missing executable to a public
+package. Trivy cannot detect this class because no installed package version
+needs to be vulnerable.
+
+Load `infrastructure_lifecycle` when source, images, firmware, or history contain abandoned domains, provider resources, package namespaces, update URLs, mail identities, telemetry, or control endpoints. Use targeted string/dataflow analysis when this is the research question; the full baseline scanner bundle is not required merely to trace one endpoint consumer.
+
+## Secret and Supply Chain Coverage
+
+Detect hardcoded credentials:
+
+```bash
+gitleaks detect --source . --report-format json --report-path /workspace/.source-aware/gitleaks.json
+trufflehog filesystem --json . > /workspace/.source-aware/trufflehog.json
+```
+
+Run repository-wide dependency and config checks:
+
+```bash
+trivy fs --scanners vuln,misconfig --timeout 30m --offline-scan \
+  --format json --output /workspace/.source-aware/trivy-fs.json . || true
+```
+
+Known-CVE dependency findings are the one exception to the "report only after
+dynamic validation" rule below: report each one with `create_dependency_report`
+(not `create_vulnerability_report`), setting `advisory_cvss` from the published
+advisory. `load_skill(["dependency_cve_scanning"])` for the full SCA workflow.
+
+## JavaScript-Side Coverage
+
+For frontends and Node services, layer these on top of the language-agnostic
+passes above:
+
+```bash
+retire --path . --outputformat json --outputpath /workspace/.source-aware/retire.json || true
+eslint --no-config-lookup --rule '{"no-eval":2,"no-implied-eval":2}' \
+  -f json -o /workspace/.source-aware/eslint.json . || true
+```
+
+When you hit a minified bundle, run `js-beautify <file>` for a readable
+view before greppping — and use `jshint --reporter=unix <file>` as a
+lighter syntax/anti-pattern check when ESLint is over-eager. The
+`JS-Snooper` / `jsniper.sh` tools (in `katana.md`) are the right next
+step to mine those bundles for endpoint candidates.
+
+## Converting Static Signals Into Exploits
+
+When source contains model-provider SDKs, prompt templates, retrieval/vector stores, tool/function calling, model loading, training/feedback pipelines, or token/agent-loop accounting, load `llm_applications`. Use its OWASP 2026 LLM01-LLM10 map to trace data provenance, model output, retrieval authorization, tool authority, and resource multipliers rather than treating the provider call as the sink.
+
+1. Rank candidates by impact and exploitability.
+2. Trace source-to-sink flow for top candidates.
+3. Build dynamic PoCs that reproduce the suspected issue.
+4. Report only after dynamic validation succeeds.
+
+## Anti-Patterns
+
+- Do not treat scanner output as final truth.
+- Do not spend full cycles on low-signal pattern matches.
+- Do not report source-only findings without validation evidence.

package/skills/frameworks/django.md

@@ -0,0 +1,214 @@
+---
+name: django
+description: Security testing playbook for Django applications covering ORM injection, middleware gaps, auth/session flaws, and template issues
+---
+
+# Django
+
+Security testing for Django web applications and Django REST Framework (DRF) APIs. Focus on ORM/raw query misuse, middleware ordering, permission class gaps, and session/auth configuration across views, admin, and channels.
+
+## Attack Surface
+
+**Core Components**
+- URL routing (`urls.py`), class-based and function views, middleware stack
+- ORM (QuerySet filters), raw SQL, `extra()`, `RawSQL`, annotations
+- Templates (Django template language, Jinja2 if configured)
+- Forms, ModelForms, serializers (DRF)
+
+**Authentication**
+- Session framework, `AuthenticationMiddleware`, `@login_required`, DRF `permission_classes`
+- Token auth, JWT (djangorestframework-simplejwt), OAuth integrations
+- Django admin (`/admin/`), staff/superuser flags
+
+**Deployment**
+- `DEBUG=True` exposure, `ALLOWED_HOSTS`, `SECRET_KEY` leakage
+- Static/media serving, reverse proxies, ASGI (Channels, Daphne, Uvicorn)
+
+## High-Value Targets
+
+- `/admin/` — brute force, credential stuffing, IDOR on admin objects
+- API endpoints with mixed permission classes across ViewSets
+- File upload (`FileField`, `ImageField`), import/export (django-import-export)
+- Search/filter endpoints using `filter()`, `Q` objects, or raw SQL
+- Password reset, email verification, invitation tokens
+- WebSocket consumers (Django Channels) with weaker auth than HTTP equivalents
+- Celery task triggers accepting user IDs without ownership checks
+
+## Reconnaissance
+
+**Fingerprinting**
+```
+curl -I https://target/ -H "Cookie: sessionid=test"
+# X-Frame-Options, Set-Cookie (sessionid, csrftoken), Server header
+GET /admin/login/
+GET /api/  /api/v1/  /swagger/  /api/schema/
+```
+
+**Settings Leakage (when DEBUG=True or misconfigured)**
+- Yellow debug page exposes `SECRET_KEY`, database credentials, installed apps
+- `/static/`, error pages with stack traces revealing paths and ORM queries
+
+**OpenAPI / DRF**
+```
+GET /api/schema/
+GET /swagger.json
+```
+Map endpoints, authentication classes, and permission classes per route.
+
+## Key Vulnerabilities
+
+### Authentication & Authorization
+
+**Permission Class Gaps**
+- ViewSet with `list` protected but `retrieve`/`update` missing `permission_classes`
+- Custom permissions checking authentication but not object ownership (IDOR)
+- `@api_view` without explicit permissions inheriting permissive defaults
+- Admin actions or custom management commands without staff checks
+
+**Session Issues**
+- `SESSION_COOKIE_SECURE=False` on HTTPS sites; missing `HttpOnly`
+- Session fixation if session key not rotated on login
+- Weak or leaked `SECRET_KEY` → forge session cookies (`django.contrib.sessions.backends.signed_cookies`)
+
+**JWT (simplejwt)**
+- RS256→HS256 confusion if algorithm pinning is misconfigured
+- Missing `user_id`/`token` blacklist on logout
+- Refresh token rotation not enforced
+
+### Injection
+
+**ORM SQL Injection**
+Vulnerable patterns (more common in legacy code):
+```python
+User.objects.raw(f"SELECT * FROM auth_user WHERE username = '{user_input}'")
+User.objects.extra(where=[f"username = '{user_input}'"])
+```
+Test: `' OR 1=1 --`, time-based payloads, database-specific syntax.
+
+**DRF Filter Backends**
+- `django-filter` with unsafe field exposure: `?username__icontains=` on unintended columns
+- Ordering injection via `?ordering=` if field whitelist missing
+
+**Template Injection**
+Django templates auto-escape by default; risk rises with:
+```python
+mark_safe(user_input)
+|safe filter in templates
+Template(user_input).render(...)  # SSTI if user controls template source
+```
+Jinja2 backend without autoescape: `{{7*7}}`, RCE gadgets if sandbox misconfigured.
+
+### CSRF
+
+- `@csrf_exempt` on state-changing views
+- DRF session authentication without CSRF enforcement on unsafe methods
+- CSRF cookie not set (`CSRF_USE_SESSIONS`, trusted origins misconfiguration)
+- `CSRF_TRUSTED_ORIGINS` too broad
+
+**Test:** Cross-origin POST with victim session cookie; JSON endpoints with session auth.
+
+### IDOR and Mass Assignment
+
+**DRF Serializers**
+- `fields = '__all__'` exposing `is_staff`, `is_superuser`, `role`, `balance`
+- `read_only_fields` missing on sensitive ModelSerializer fields
+- Nested writes updating foreign keys across tenants
+
+**Object-Level Permissions**
+- `get_object()` without filtering queryset by request.user
+- Generic views with `queryset = Model.objects.all()` and weak permissions
+
+### File Handling
+
+- `MEDIA_ROOT` served directly in DEBUG or via misconfigured nginx
+- Path traversal in custom file download views using user-supplied paths
+- SVG/HTML uploads served with `Content-Type` that enables XSS
+- Missing file size/type validation on uploads
+
+### SSRF
+
+- `requests.get(user_url)` in webhooks, preview, import features
+- Celery tasks fetching user URLs server-side
+- Test loopback, metadata IPs, redirect chains
+
+### Host Header / Password Reset
+
+- `ALLOWED_HOSTS = ['*']` or permissive subdomain patterns
+- Password reset emails built from `Host` header → poisoned reset links
+- Cache poisoning via unkeyed Host header on cached pages
+
+### Django Admin
+
+- Default `/admin/` path with weak credentials
+- `has_add_permission` / `has_change_permission` overrides with logic bugs
+- ModelAdmin exposing sensitive fields in list_display or export
+
+### Channels / WebSocket
+
+- Consumer accepts connection without session/auth parity to HTTP
+- Group name derived from user input → subscribe to other users' channels
+- Missing origin validation on WebSocket handshake
+
+## Bypass Techniques
+
+- Content negotiation: JSON vs form data hitting different parser/permission paths
+- HTTP method override or trailing slash routing to alternate view
+- Parameter pollution: duplicate `id` fields in query and body
+- Race on state transitions (coupon redemption, inventory) via parallel requests
+- Versioned API (`/api/v1/` vs `/api/v2/`) with weaker auth on older version
+
+## Testing Methodology
+
+1. **Map surface** — URLs, DRF schema, admin, static/media paths
+2. **Auth matrix** — Unauthenticated/user/staff for each endpoint and method
+3. **Object ownership** — Swap IDs across two user accounts on every CRUD route
+4. **Serializer audit** — Identify writable sensitive fields and nested relations
+5. **Middleware order** — Confirm auth runs before business logic; check CSRF on session APIs
+6. **Channel parity** — Same authorization on WebSocket actions as REST equivalents
+7. **Settings review (white-box)** — DEBUG, ALLOWED_HOSTS, SECRET_KEY, session/cookie flags
+
+## Validation
+
+1. Side-by-side requests proving unauthorized access (IDOR, privilege escalation)
+2. CSRF PoC executing state change with victim session (for session-authenticated endpoints)
+3. SQLi/template injection with deterministic oracle (error, timing, or `7*7` equivalent)
+4. Document view/serializer/permission class where enforcement failed
+5. Show admin or staff capability gained from regular user context if applicable
+
+## False Positives
+
+- `queryset.filter(user=request.user)` consistently applied including nested routes
+- Object-level permission class correctly validates ownership on all actions
+- DEBUG=False and generic error pages with no settings leakage confirmed
+- Mark_safe used only on server-generated trusted content
+- CSRF correctly enforced on all session-authenticated unsafe methods
+
+## Impact
+
+- Account takeover via session forgery or password reset poisoning
+- Horizontal/vertical privilege escalation through IDOR and mass assignment
+- Data breach via ORM/SQL injection or excessive serializer fields
+- Server compromise via SSTI, pickle in cache (if used), or SSRF to internal services
+
+## Pro Tips
+
+1. DRF ViewSets often protect `list` but forget `destroy` or custom `@action` routes
+2. Check `APIView` subclasses for missing `permission_classes` — common oversight
+3. Test `?format=` and browsable API HTML responses for CSRF on session auth
+4. `django.contrib.admin` uses separate auth — don't assume API auth covers admin
+5. Compare ASGI WebSocket consumers against REST permissions for the same resource
+
+## Tooling
+
+Static analysis is the fastest way to reach the sinks above in white-box scope. The sandbox ships `python`/`pipx`, `semgrep`, `bandit`, `ast-grep`, and `ripgrep`.
+
+- **bandit** (preinstalled) — Python security linter; flags `mark_safe`, `extra()`, `RawSQL`, `subprocess`, weak crypto, hardcoded secrets: `bandit -r . -ll`
+- **semgrep** (preinstalled) with the Django ruleset — higher-signal than bandit for framework-specific bugs (`.extra()`, `RawSQL`, `|safe`, `csrf_exempt`, `ALLOWED_HOSTS=['*']`): `semgrep --config p/django .`
+- **pip-audit** (PyPA) — dependency CVE scanner for known-vuln Django/DRF/simplejwt versions: `pipx install pip-audit && pip-audit -r requirements.txt`
+- **ast-grep** (preinstalled) — quick structural grep for risky calls without a full SAST run: `ast-grep run -p 'mark_safe($X)' -l python`
+
+For the `SECRET_KEY` → signed-cookie/reset-token forgery path noted under Session Issues, Django's own `django.core.signing` is the "tool": with a leaked key you can mint valid `signing.dumps()` values (session cookies, password-reset tokens, and `PickleSerializer`-backed session RCE).
+
+## Summary
+
+Django's defaults help (CSRF middleware, template auto-escape) but DRF, raw SQL, custom permissions, and deployment settings introduce frequent gaps. Test every endpoint with role-separated principals and verify object-level enforcement on querysets, not just authentication presence.

package/skills/frameworks/fastapi.md

@@ -0,0 +1,191 @@
+---
+name: fastapi
+description: Security testing playbook for FastAPI applications covering ASGI, dependency injection, and API vulnerabilities
+---
+
+# FastAPI
+
+Security testing for FastAPI/Starlette applications. Focus on dependency injection flaws, middleware gaps, and authorization drift across routers and channels.
+
+## Attack Surface
+
+**Core Components**
+- ASGI middlewares: CORS, TrustedHost, ProxyHeaders, Session, exception handlers, lifespan events
+- Routers and sub-apps: APIRouter prefixes/tags, mounted apps (StaticFiles, admin), `include_router`, versioned paths
+- Dependency injection: `Depends`, `Security`, `OAuth2PasswordBearer`, `HTTPBearer`, scopes
+
+**Data Handling**
+- Pydantic models: v1/v2, unions/Annotated, custom validators, extra fields policy, coercion
+- File operations: UploadFile, File, FileResponse, StaticFiles mounts
+- Templates: Jinja2Templates rendering
+
+**Channels**
+- HTTP (sync/async), WebSocket, SSE/StreamingResponse
+- BackgroundTasks and task queues
+
+**Deployment**
+- Uvicorn/Gunicorn, reverse proxies/CDN, TLS termination, header trust
+
+## High-Value Targets
+
+- `/openapi.json`, `/docs`, `/redoc` in production (full attack surface map, securitySchemes, server URLs)
+- Auth flows: token endpoints, session/cookie bridges, OAuth device/PKCE
+- Admin/staff routers, feature-flagged routes, `include_in_schema=False` endpoints
+- File upload/download, import/export/report endpoints, signed URL generators
+- WebSocket endpoints (notifications, admin channels, commands)
+- Background job endpoints (`/jobs/{id}`, `/tasks/{id}/result`)
+- Mounted subapps (admin UI, storage browsers, metrics/health)
+
+## Reconnaissance
+
+**OpenAPI Mining**
+```
+GET /openapi.json
+GET /docs
+GET /redoc
+GET /api/openapi.json
+GET /internal/openapi.json
+```
+
+Extract: paths, parameters, securitySchemes, scopes, servers. Endpoints with `include_in_schema=False` won't appear—fuzz based on discovered prefixes and common admin/debug names.
+
+**Dependency Mapping**
+
+For each route, identify:
+- Router-level dependencies (applied to all routes)
+- Route-level dependencies (per endpoint)
+- Which dependencies enforce auth vs just parse input
+
+## Key Vulnerabilities
+
+### Authentication & Authorization
+
+**Dependency Injection Gaps**
+- Routes missing security dependencies present on other routes
+- `Depends` used instead of `Security` (ignores scope enforcement)
+- Token presence treated as authentication without signature verification
+- `OAuth2PasswordBearer` only yields a token string—verify routes don't treat presence as auth
+
+**JWT Misuse**
+- Decode without verify: test unsigned tokens, attacker-signed tokens
+- Algorithm confusion: HS256/RS256 cross-use if not pinned
+- `kid` header injection for custom key lookup paths
+- Missing issuer/audience validation, cross-service token reuse
+
+**Session Weaknesses**
+- SessionMiddleware with weak `secret_key`
+- Session fixation via predictable signing
+- Cookie-based auth without CSRF protection
+
+**OAuth/OIDC**
+- Device/PKCE flows: verify strict PKCE S256 and state/nonce enforcement
+
+### Access Control
+
+**IDOR via Dependencies**
+- Object IDs in path/query not validated against caller
+- Tenant headers trusted without binding to authenticated user
+- BackgroundTasks acting on IDs without re-validating ownership at execution time
+- Export/import pipelines with IDOR and cross-tenant leaks
+
+**Scope Bypass**
+- Minimal scope satisfaction (any valid token accepted)
+- Router vs route scope enforcement inconsistency
+
+### Input Handling
+
+**Pydantic Exploitation**
+- Type coercion: strings to ints/bools, empty strings to None, truthiness edge cases
+- Extra fields: `extra = "allow"` permits injecting control fields (role, ownerId, scope)
+- Union types and `Annotated`: craft shapes hitting unintended validation branches
+
+**Content-Type Switching**
+```
+application/json ↔ application/x-www-form-urlencoded ↔ multipart/form-data
+```
+Different content types hit different validators or code paths (parser differentials).
+
+**Parameter Manipulation**
+- Case variations in header/cookie names
+- Duplicate parameters exploiting DI precedence
+- Method override via `X-HTTP-Method-Override` (upstream respects, app doesn't)
+
+### CORS & CSRF
+
+**CORS Misconfiguration**
+- Overly broad `allow_origin_regex`
+- Origin reflection without validation
+- Credentialed requests with permissive origins
+- Verify preflight vs actual request deltas
+
+**CSRF Exposure**
+- No built-in CSRF in FastAPI/Starlette
+- Cookie-based auth without origin validation
+- Missing SameSite attribute
+
+### Proxy & Host Trust
+
+**Header Spoofing**
+- ProxyHeadersMiddleware without network boundary: spoof `X-Forwarded-For/Proto` to influence auth/IP gating
+- Absent TrustedHostMiddleware: Host header poisoning in password reset links, absolute URL generation
+- Cache key confusion: missing Vary on Authorization/Cookie/Tenant
+
+### Server-Side Vulnerabilities
+
+**Template Injection (Jinja2)**
+```python
+{{7*7}}  # Arithmetic confirmation
+{{cycler.__init__.__globals__['os'].popen('id').read()}}  # RCE
+```
+Check autoescape settings and custom filters/globals.
+
+**SSRF**
+- User-supplied URLs in imports, previews, webhooks validation
+- Test: loopback, RFC1918, IPv6, redirects, DNS rebinding, header control
+- Library behavior (httpx/requests): redirect policy, header forwarding, protocol support
+- Protocol smuggling: `file://`, `ftp://`, gopher-like shims if custom clients
+
+**File Upload**
+- Path traversal in `UploadFile.filename` with control characters
+- Missing storage root enforcement, symlink following
+- Vary filename encodings, dot segments, NUL-like bytes
+- Verify storage paths and served URLs
+
+### WebSocket Security
+
+- Missing per-connection authentication
+- Cross-origin WebSocket without origin validation
+- Topic/channel IDOR (subscribing to other users' channels)
+- Authorization only at handshake, not per-message
+
+### Mounted Apps
+
+Sub-apps at `/admin`, `/static`, `/metrics` may bypass global middlewares. Verify auth enforcement parity across all mounts.
+
+### Alternative Stacks
+
+- If GraphQL (Strawberry/Graphene) is mounted: validate resolver-level authorization, IDOR on node/global IDs
+- If SQLModel/SQLAlchemy present: probe for raw query usage and row-level authorization gaps
+
+## Bypass Techniques
+
+- Content-type switching to traverse alternate validators
+- Parameter duplication and case variants exploiting DI precedence
+- Method confusion via proxies (`X-HTTP-Method-Override`)
+- Race windows around dependency-validated state transitions (issue token then mutate with parallel requests)
+
+## Testing Methodology
+
+1. **Enumerate** - Fetch OpenAPI, diff with 404-fuzzing for hidden endpoints
+2. **Matrix testing** - Test each route across: unauth/user/admin × HTTP/WebSocket × JSON/form/multipart
+3. **Dependency analysis** - Map which dependencies enforce auth vs parse input
+4. **Cross-environment** - Compare dev/stage/prod for middleware and docs exposure differences
+5. **Channel consistency** - Verify same authorization on HTTP and WebSocket for equivalent operations
+
+## Validation Requirements
+
+- Side-by-side requests showing unauthorized access (owner vs non-owner, cross-tenant)
+- Cross-channel proof (HTTP and WebSocket for same rule)
+- Header/proxy manipulation showing altered outcomes (Host/XFF/CORS)
+- Minimal payloads for template injection, SSRF, token misuse with safe/OAST oracles
+- Document exact dependency paths (router-level, route-level) that missed enforcement