--- name: web-perimeter-owasp-2025-audit 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 Security Audit (OWASP Top 10:2025 Surface Leads) 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. ## 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, 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. ## When to Activate - 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`, `/.npmrc`, `/.yarnrc.yml`, source maps) and AI crawler boundaries (`llms.txt`, `robots.txt`, `security.txt`) ## Perimeter Audit Workflow ### 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 (`--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:[[:space:]]*MISS([[:space:]]|$)|x-cache:[[:space:]]*Miss([[:space:]]|$))' "${WORK_DIR}/iso_b_headers.txt" || grep -Eiq '^(cf-cache-status:[[:space:]]*HIT|x-cache:[[:space:]]*Hit|age:[[:space:]]*[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}$ && "${CB_PROBE}" != "${CB_A}" && "${CB_PROBE}" != "${CB_B}" ]] || 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" # 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). - Explicitly probe `/.npmrc` and `/.yarnrc.yml` using bounded, non-exfiltrating signatures (`--connect-timeout 3 --max-time 5`): check whether HTTP status is `200` and lines match `^(registry|@[a-z0-9_-]+:registry|//[^:]+:_authToken|npmScopes:|npmRegistries:|npmAuthToken:|nodeLinker:)` without `` tags loaded from external CDNs. ### 3. Transport & Browser Policy Leads (Related to A04 / A05:2025) 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). ### 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 (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. ### 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_`) 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`. ## Optional External Verification (Explicit Opt-In Only) By default, perform all checks locally using the `curl` workflows above so private or staging hostnames never leave the local environment. If the user explicitly authorizes third-party scanning for a public domain, pin the exact CLI package version before execution: ```bash # Opt-in only (requires user approval for external package execution / domain disclosure): npx @stealthmark/cli@0.1.6 audit https://example.com ``` ## Remediation Reference (Next.js Headers + Path Denial Middleware) `next.config.ts` `headers()` attaches response headers only—it does **not** block access to sensitive paths. Pair `next.config.ts` with edge `middleware.ts` (or upstream Nginx/Cloudflare rules) to deny access to hidden repository metadata and lockfiles while preserving intentional public discovery endpoints: ```typescript // 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: HSTS_POLICY }, { key: "X-Content-Type-Options", value: "nosniff" }, { key: "X-Frame-Options", value: "DENY" }, { key: "Referrer-Policy", value: "strict-origin-when-cross-origin" }, { key: "Permissions-Policy", value: "camera=(), microphone=(), geolocation=()" }, { key: "Vary", value: "Accept-Encoding, Origin" }, ]; const nextConfig: NextConfig = { poweredByHeader: false, productionBrowserSourceMaps: false, async headers() { return [{ source: "/:path*", headers: securityHeaders }]; }, }; export default nextConfig; ``` ```typescript // 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([ "/.well-known/security.txt", "/.well-known/agent.json", ]); const BLOCKED_PATH_PREFIXES = [ "/.git", "/.npmrc", "/.yarnrc.yml", "/package.json", "/package-lock.json", "/pnpm-lock.yaml", "/yarn.lock", ]; export function middleware(request: NextRequest) { const { pathname } = request.nextUrl; if ( (pathname.startsWith("/.") && !PUBLIC_WELL_KNOWN_PATHS.has(pathname)) || BLOCKED_PATH_PREFIXES.some((prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`)) ) { return new NextResponse(null, { status: 404 }); } return NextResponse.next(); } ```