From 3f9929e0d8d0102079e322d98fa34075e7ab80cb Mon Sep 17 00:00:00 2001 From: StealthMark Security Team Date: Sun, 1 Nov 2026 02:33:18 +0000 Subject: [PATCH] fix(skills): make HSTS conditional, bound cache probe with mktemp/fixture, and scope OWASP perimeter leads --- .../web-perimeter-owasp-2025-audit/SKILL.md | 168 ++++++++++++++---- 1 file changed, 135 insertions(+), 33 deletions(-) diff --git a/skills/web-perimeter-owasp-2025-audit/SKILL.md b/skills/web-perimeter-owasp-2025-audit/SKILL.md index 52ecc70ed..2bb7964fe 100644 --- a/skills/web-perimeter-owasp-2025-audit/SKILL.md +++ b/skills/web-perimeter-owasp-2025-audit/SKILL.md @@ -1,18 +1,31 @@ --- name: web-perimeter-owasp-2025-audit -description: Passive, non-destructive web perimeter security auditing across OWASP Top 10:2025 ("The 10 Gates"), CDN Unkeyed Header Web Cache Poisoning (X-Forwarded-Host), supply chain manifest exposure, git object dumping prevention (/.git/HEAD), cryptographic headers, and AI crawler boundary governance (llms.txt, robots.txt). Use when auditing production domains, configuring Cloudflare/Vercel/Nginx edge security, or preparing pre-launch security gates. +description: Passive, non-destructive web perimeter security auditing mapped to OWASP Top 10:2025 surface leads, CDN Unkeyed Header Web Cache Poisoning (X-Forwarded-Host), supply chain manifest exposure, git object dumping prevention (/.git/HEAD), cryptographic headers, and AI crawler boundary governance (llms.txt, robots.txt). Use when auditing production domains, configuring Cloudflare/Vercel/Nginx edge security, or preparing pre-launch perimeter checks. metadata: origin: ECC --- -# Web Perimeter & OWASP Top 10:2025 Audit +# Web Perimeter Security Audit (OWASP Top 10:2025 Surface Leads) -Conduct non-destructive, deterministic perimeter security audits against web applications, APIs, and CDN edges. Map every finding to **OWASP Top 10:2025 ("The 10 Gates")** and verify fixes with reproducible checks before shipping to production. +Conduct non-destructive, deterministic perimeter security audits against web applications, APIs, and CDN edges. Map observable edge findings to relevant **OWASP Top 10:2025** categories as **perimeter leads**, and verify fixes with reproducible checks before shipping to production. -## Important +## Scope & Unverified Application-Layer Areas + +External HTTP response headers, CDN cache behavior, crawler policies, and disclosure files only inspect the **publicly observable edge perimeter**. Passing this checklist does **not** establish full OWASP Top 10:2025 compliance. Always report the following application-layer areas as **unverified by perimeter probing** unless backed by separate code review and authenticated testing: + +- **Authorization & Object-Level Access Control (A01:2025):** BOLA/IDOR, tenant isolation, and privilege escalation require authenticated multi-role integration tests ([OWASP Authorization Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Authorization_Cheat_Sheet.html)). +- **Authentication & Session Lifecycle (A07:2025):** MFA enforcement, credential stuffing defenses, token rotation, and server-side session revocation cannot be proven from `Set-Cookie` flags alone ([OWASP Authentication Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html)). +- **Injection & Business Logic Processing (A05 / A06:2025):** SQL/NoSQL/command injection, SSRF, and race conditions require source analysis (SAST) and targeted DAST ([OWASP Injection Prevention Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Injection_Prevention_Cheat_Sheet.html)). +- **Internal Security Logging & Alerting (A09:2025):** Audit trail completeness, tamper resistance, and SIEM alerting must be verified inside the telemetry pipeline ([OWASP Logging Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Logging_Cheat_Sheet.html)). + +## Important Safety Contract - Never send destructive payloads, brute-force traffic, or unisolated cache-poisoning probes against shared production cache keys. -- Before sending any `X-Forwarded-Host` or `X-Forwarded-Scheme` probe against a live target, first prove query-key isolation using fresh random per-run values (`CB_A=$(openssl rand -hex 8)` and `CB_B=$(openssl rand -hex 8)`): send a clean request with `?__cb=${CB_A}` (`--max-time 5`), repeat the identical `?__cb=${CB_A}` request at most twice (max 3 requests total, `--max-time 5` each) to confirm a cache `HIT`, and then send a single clean request with `?__cb=${CB_B}` (`--max-time 5`) and verify it produces a cache `MISS`. If `HIT` followed by `MISS` is not confirmed within those bounded attempts, abort the live probe and run it only against an isolated staging environment. +- Before sending any `X-Forwarded-Host` or `X-Forwarded-Scheme` probe against a live target, first prove query-key isolation using fresh, validated hexadecimal cache-busters (`set -euo pipefail`, `CB_A=$(openssl rand -hex 8)` and `CB_B=$(openssl rand -hex 8)`): + 1. Fail closed before sending any request if `CB_A` or `CB_B` is empty, equal, or does not match `^[0-9a-f]{16}$`. + 2. Send a clean request with `?__cb=${CB_A}` (`--connect-timeout 3 --max-time 5`), repeat the identical `?__cb=${CB_A}` request at most twice (max 3 requests total, `--max-time 5` each) to confirm a cache `HIT`, and then send a single clean request with `?__cb=${CB_B}` (`--max-time 5`) and verify it produces a cache `MISS`. + 3. If `HIT` followed by `MISS` is not confirmed within those bounded attempts, abort the live probe and run it only against an isolated staging environment. +- Use a private `mktemp -d` working directory with `trap` cleanup for all captured headers and bodies; never write to predictable shared `/tmp` filenames. - Verify real HTTP responses rather than relying on framework defaults; reverse proxies and CDNs frequently strip or override upstream headers. - Treat `403 Forbidden` on directory roots (such as `/.git/`) as insufficient unless direct object paths (`/.git/HEAD`, `/.git/config`) also return `404`/`403`. - Keep all checks local by default (`curl` / standard system tools). Only invoke external CLIs or remote scorecard APIs when the user explicitly opts in and approves sharing the target hostname. @@ -22,70 +35,149 @@ Conduct non-destructive, deterministic perimeter security audits against web app - Auditing a live domain or staging environment before launch - Reviewing Cloudflare, Vercel, AWS CloudFront, Nginx, or Next.js middleware security configurations - Investigating CDN Web Cache Poisoning (`X-Forwarded-Host`, `X-Forwarded-Scheme`) or CORS origin reflection -- Hardening supply chain artifacts (`package-lock.json`, registry config files, source maps) and AI crawler boundaries (`llms.txt`, `robots.txt`, `security.txt`) +- Hardening supply chain artifacts (`package-lock.json`, `/.npmrc`, `/.yarnrc.yml`, source maps) and AI crawler boundaries (`llms.txt`, `robots.txt`, `security.txt`) -## Audit Workflow: The 10 Gates (OWASP Top 10:2025) +## Perimeter Audit Workflow -### Gate 1 & Gate 2: Broken Access Control & Security Misconfiguration (A01 / A02:2025) +### 1. Exposed Artifacts, CORS & Cache Isolation Leads (Related to A01 / A02:2025) 1. **Direct Git Object & Config Artifact Exposure (`git-dumper` vector):** - Disabling directory indexing on `/.git/` (`403 Forbidden`) does **not** prevent repository reconstruction if direct object paths remain readable. - - Probe each path using a bounded, file-specific signature without printing sensitive contents: + - Probe each path using a bounded, file-specific signature (`--connect-timeout 3 --max-time 5`) without printing sensitive contents: - `/.git/HEAD`: check if status is `200` and the first line matches `^ref: refs/` or a 40-character hex SHA (`^[0-9a-f]{40}$`). - `/.git/config`: check if status is `200` and the body contains `[core]` or a `[remote "` section header. - `/docker-compose.yml`: check if status is `200` and the body contains a top-level `services:` block. - Environment configuration paths (such as `/`): check if status is `200` and lines match `^[A-Z][A-Z0-9_]+=` without `&2 + exit 1 + fi + + WORK_DIR="$(mktemp -d)" + trap 'rm -rf "${WORK_DIR}"' EXIT + + TARGET_BASE="https://example.com/" + # Step 1: Prove query-key isolation (max 3 attempts for HIT on CB_A, then MISS on CB_B) + CACHE_HIT=0 + for attempt in 1 2 3; do + curl -sS --connect-timeout 3 --max-time 5 -D "${WORK_DIR}/iso_a_headers.txt" -o /dev/null "${TARGET_BASE}?__cb=${CB_A}" + if grep -Eiq '^(cf-cache-status:\s*HIT|x-cache:\s*Hit|age:\s*[1-9])' "${WORK_DIR}/iso_a_headers.txt"; then + CACHE_HIT=1 + break + fi + done + curl -sS --connect-timeout 3 --max-time 5 -D "${WORK_DIR}/iso_b_headers.txt" -o /dev/null "${TARGET_BASE}?__cb=${CB_B}" + if [[ "${CACHE_HIT}" -ne 1 ]] || grep -Eiq '^(cf-cache-status:\s*HIT|x-cache:\s*Hit|age:\s*[1-9])' "${WORK_DIR}/iso_b_headers.txt"; then + echo "Aborting live probe: query-key cache isolation not proven; use isolated staging." >&2 + exit 1 + fi + + # Step 2: Isolated GET probe on a fresh cache-buster key + CB_PROBE="$(openssl rand -hex 8)" + [[ "${CB_PROBE}" =~ ^[0-9a-f]{16}$ ]] || exit 1 + PROBE_URL="${TARGET_BASE}?__cb=${CB_PROBE}" + + curl -sS --connect-timeout 3 --max-time 5 \ + -D "${WORK_DIR}/probe_headers.txt" -o "${WORK_DIR}/probe_body.txt" "${PROBE_URL}" \ -H "X-Forwarded-Host: cache-probe.invalid" \ -H "X-Forwarded-Scheme: nothttps" - # 2) Immediately send a clean follow-up GET to the identical URL without probe headers - curl -sS -D /tmp/clean_headers.txt -o /tmp/clean_body.txt "${URL}" - ``` - - Flag **MEDIUM (Unkeyed Input Reflection)** if `cache-probe.invalid` appears in `/tmp/probe_headers.txt` (`Location`) or `/tmp/probe_body.txt` on the first request alone. - - Escalate to **HIGH (Confirmed Web Cache Poisoning)** only when the subsequent clean follow-up request (`/tmp/clean_headers.txt` and `/tmp/clean_body.txt`) is served from cache (`CF-Cache-Status: HIT`, `X-Cache: Hit from cloudfront`, or `Age > 0`) **and** replays the injected `cache-probe.invalid` reflection or poisoned `4xx`/`5xx` status. -### Gate 3 & Gate 8: Software Supply Chain & Data Integrity Failures (A03 / A08:2025) + # Step 3: Clean follow-up GET to the identical URL without probe headers + curl -sS --connect-timeout 3 --max-time 5 \ + -D "${WORK_DIR}/clean_headers.txt" -o "${WORK_DIR}/clean_body.txt" "${PROBE_URL}" + ``` + - Flag **MEDIUM (Unkeyed Input Reflection)** if `cache-probe.invalid` appears in `${WORK_DIR}/probe_headers.txt` (`Location`) or `${WORK_DIR}/probe_body.txt` on the first request alone. + - Escalate to **HIGH (Confirmed Web Cache Poisoning)** only when the subsequent clean follow-up request (`${WORK_DIR}/clean_headers.txt` and `${WORK_DIR}/clean_body.txt`) is served from cache (`CF-Cache-Status: HIT`, `X-Cache: Hit from cloudfront`, or `Age > 0`) **and** replays the injected `cache-probe.invalid` reflection or poisoned `4xx`/`5xx` status. + - **Self-Contained Local Staging Fixture (Positive Replay vs. Negative Control):** + To validate your detection logic locally without touching external networks, run this loopback fixture: + ```bash + python3 - << 'EOF' + import http.server, threading, urllib.request + + STORE = {} + class EdgeFixture(http.server.BaseHTTPRequestHandler): + def log_message(self, *args): pass + def do_GET(self): + mode, _, query = self.path.partition("?") + xfh = self.headers.get("X-Forwarded-Host", "clean.example") + # /vulnerable caches by query only (unkeyed X-Forwarded-Host) + # /safe includes X-Forwarded-Host in the cache key (negative control) + key = (mode, query) if mode == "/vulnerable" else (mode, query, xfh) + if key in STORE: + body, hit = STORE[key], "HIT" + else: + body = f"".encode() + STORE[key], hit = body, "MISS" + self.send_response(200) + self.send_header("CF-Cache-Status", hit) + self.end_headers() + self.wfile.write(body) + + srv = http.server.HTTPServer(("127.0.0.1", 0), EdgeFixture) + port = srv.server_port + threading.Thread(target=srv.serve_forever, daemon=True).start() + + def check_path(path): + url = f"http://127.0.0.1:{port}{path}?__cb=deadbeef01234567" + req1 = urllib.request.Request(url, headers={"X-Forwarded-Host": "cache-probe.invalid"}) + urllib.request.urlopen(req1, timeout=3).read() + resp2 = urllib.request.urlopen(url, timeout=3) + body2 = resp2.read().decode() + hit2 = resp2.headers.get("CF-Cache-Status") + return hit2 == "HIT" and "cache-probe.invalid" in body2 + + assert check_path("/vulnerable") is True, "Expected positive replay detection on /vulnerable" + assert check_path("/safe") is False, "Expected negative control to stay clean on /safe" + srv.shutdown() + print("Staging fixture verified: positive replay detected and negative control clean.") + EOF + ``` + +### 2. Software Supply Chain & Integrity Leads (Related to A03 / A08:2025) 1. **Public Lockfile & Registry Config Exposure:** - Verify that `/package.json`, `/package-lock.json`, `/pnpm-lock.yaml`, and `/yarn.lock` return `404` or `403` in production so attackers cannot harvest your exact dependency tree (SBOM). - - Probe package-manager registry configuration paths (`/.yarnrc.yml` and package-manager registry config files) using bounded, non-exfiltrating signatures (for example, checking whether status is `200` and lines match `^(registry|@[a-z0-9_-]+:registry|npmScopes:|nodeLinker:)` without `` tags loaded from external CDNs. -### Gate 4 & Gate 5: Cryptographic Failures & Injection Boundaries (A04 / A05:2025) +### 3. Transport & Browser Policy Leads (Related to A04 / A05:2025) -1. **Strict Transport Security (HSTS) & TLS Posture:** - - Verify `Strict-Transport-Security: max-age=63072000; includeSubDomains; preload` (`max-age >= 31536000`) and ensure plain `http://` redirects immediately (`301`/`308`) to `https://`. +1. **Conditional Strict Transport Security (HSTS) & TLS Posture:** + - Verify that plain `http://` redirects immediately (`301`/`308`) to `https://` and that HTTPS responses include `Strict-Transport-Security` with an appropriate `max-age` (e.g., `max-age=31536000`). + - Treat `includeSubDomains` and `preload` as **conditional deployment decisions**, not universal defaults: + - Only add `includeSubDomains` after confirming that **every** subdomain under the registered domain supports valid HTTPS; otherwise browsers will refuse connections to HTTP-only internal or legacy subdomains. + - Keep `preload` submission a separate, explicit operational decision after reviewing the [HSTS preload requirements](https://hstspreload.org/), because removal from browser preload lists takes months to propagate. 2. **Content-Security-Policy (CSP) Evaluation:** - Verify that `Content-Security-Policy` defines `default-src`, `script-src`, `object-src 'none'`, `base-uri 'self'`, and `frame-ancestors`. - Flag `script-src 'unsafe-eval'` **independently** whenever present, because cryptographic nonces (`'nonce-...'`) and hashes (`'sha256-...'`) only neutralize `'unsafe-inline'` and do **not** disable `eval()` or string-to-code execution. - Flag `script-src 'unsafe-inline'` unless accompanied by `'strict-dynamic'` or per-response nonces/hashes (and no `unsafe-inline` fallback in modern browsers). -### Gate 6 & Gate 7: Insecure Design, Bot Governance & Auth Hardening (A06 / A07:2025) +### 4. Crawler Boundary & Session Cookie Leads (Related to A06 / A07:2025) 1. **AI Crawler & Agentic Boundary Governance:** - Verify whether `robots.txt` explicitly defines rules for AI crawlers (`GPTBot`, `ClaudeBot`, `PerplexityBot`, `Google-Extended`, `CCBot`) and whether `/llms.txt` or `/.well-known/agent.json` declares machine-readable usage policies. - Because attackers routinely spoof `User-Agent: ChatGPT-User` or `Googlebot` to bypass naive WAF rules, never trust `User-Agent` strings alone: verify crawlers using **Forward-Confirmed Reverse DNS (FCrDNS)** (`PTR` lookup on the client IP followed by a forward `A`/`AAAA` lookup confirming the IP matches the official domain), official published IP CIDR lists (e.g., OpenAI/Anthropic IP ranges), or cryptographic HTTP message signatures (`RFC 9421` Web Bot Auth). -2. **Session Cookie Hardening:** +2. **Session Cookie Hardening (Perimeter Surface):** - Every `Set-Cookie` header carrying an authentication or session identifier must include `HttpOnly` and `Secure`. - Evaluate `SameSite` and lifetime against the application's architecture: - Default to `SameSite=Lax` (or `Strict`) for first-party flows; only permit `SameSite=None; Secure` when intentional cross-site embedding/federation is required and explicit anti-CSRF tokens or Fetch Metadata (`Sec-Fetch-Site`) checks are enforced. - Ephemeral browser-session cookies may intentionally omit `Max-Age` and `Expires` so they clear on browser close; persistent cookies must set a bounded `Max-Age` or `Expires` appropriate to the session risk tier. -### Gate 9 & Gate 10: Telemetry & Exceptional Conditions (A09 / A10:2025) +### 5. Error Surface & Disclosure Policy Leads (Related to A09 / A10:2025) 1. **Fail-Closed Error Handling (No Stack Trace Leaks):** - - Request a non-existent route (`/api/__probe_404_`) and verify that the server returns a clean, minimal JSON or HTML error without leaking stack traces (`java.sql.SQLException`, `PrismaClientKnownRequestError`, `Traceback`, `at Object.`, `/var/task/`, `node_modules/`). + - Request a non-existent route (`/api/__probe_404_`) with `--connect-timeout 3 --max-time 5` and verify that the server returns a clean, minimal JSON or HTML error without leaking stack traces (`java.sql.SQLException`, `PrismaClientKnownRequestError`, `Traceback`, `at Object.`, `/var/task/`, `node_modules/`). 2. **Vulnerability Disclosure Policy (`/.well-known/security.txt`):** - Verify RFC 9116 compliance (`Contact:` and non-expired `Expires:` fields) at `/.well-known/security.txt`. @@ -106,8 +198,17 @@ npx @stealthmark/cli@0.1.6 audit https://example.com // 1) next.config.ts — baseline perimeter response headers & source map hardening import type { NextConfig } from "next"; +// Add "; includeSubDomains" only after confirming every subdomain supports HTTPS. +// Add "; preload" only as an explicit decision per https://hstspreload.org/ requirements. +const HSTS_POLICY = + process.env.HSTS_ENABLE_PRELOAD === "true" + ? "max-age=63072000; includeSubDomains; preload" + : process.env.HSTS_INCLUDE_SUBDOMAINS === "true" + ? "max-age=31536000; includeSubDomains" + : "max-age=31536000"; + const securityHeaders = [ - { key: "Strict-Transport-Security", value: "max-age=63072000; includeSubDomains; preload" }, + { key: "Strict-Transport-Security", value: HSTS_POLICY }, { key: "X-Content-Type-Options", value: "nosniff" }, { key: "X-Frame-Options", value: "DENY" }, { key: "Referrer-Policy", value: "strict-origin-when-cross-origin" }, @@ -127,7 +228,7 @@ export default nextConfig; ``` ```typescript -// 2) middleware.ts — deny dotfiles, git metadata, and lockfiles while preserving public /.well-known endpoints +// 2) middleware.ts — deny dotfiles, git metadata, registry configs, and lockfiles while preserving public /.well-known endpoints import { NextResponse, type NextRequest } from "next/server"; const PUBLIC_WELL_KNOWN_PATHS = new Set([ @@ -137,6 +238,7 @@ const PUBLIC_WELL_KNOWN_PATHS = new Set([ const BLOCKED_PATH_PREFIXES = [ "/.git", + "/.npmrc", "/.yarnrc.yml", "/package.json", "/package-lock.json",