Skip to main content
Glama

⚠ Authorized use only

FSV is a security assessment tool. Use it only against systems you own or are explicitly authorized in writing to test. Scanning systems without permission is illegal in most jurisdictions. Every entry point (web, CLI, MCP, CI) requires you to confirm authorization, and a shared deployment can additionally require proof of control of the target before any payload is sent (docs/DEPLOYMENT.md).


Connect your AI assistant in 30 seconds

Point Claude, Cursor or VS Code at FSV and ask it to review your site. The assistant asks you to confirm authorization, runs a passive check, then a full scan, leads with attack paths and hands you paste-ready fixes.

pip install fsv
fsv mcp-config --client claude-code     # prints:  claude mcp add fsv -- /path/to/fsv-mcp
fsv mcp-config --client claude-desktop  # or cursor · vscode — prints the JSON to paste

No install at all: with uv, point any MCP client at uvx fsv mcp ({ "command": "uvx", "args": ["fsv", "mcp"] }). FSV is listed in the official MCP Registry as io.github.twayst0/fsv.

Then, in the assistant: “Use the security_review prompt on https://my-shop.example — I own it.”

Tool

Purpose

fsv_scan

Full scan — profiles, scope, time-box, seed_urls; headers / cookies for an authenticated scan with a test account

fsv_quick_check / fsv_waf_check

Passive posture check / WAF-CDN detection

fsv_fixes

Paste-ready nginx / apache / caddy / express / DNS remediation

fsv_get_report

md · json · html · sarif · csv · fix-*

fsv_triage

Mark false positive / accepted / fixed (persists per host)

fsv_compare_scans · fsv_target_trend

Before/after a fix · risk over time

fsv_verify_ownership

Proof of control (DNS TXT or HTTP file) for shared deployments

fsv_list_scans · fsv_scan_stats · fsv_list_modules

History · request stats · catalogue

Prompt security_review(target, server) — the guided, authorization-first workflow above. Scan results carry an attack_paths section so the agent leads with what matters. The server is tested end to end over stdio (tests/test_mcp_stdio.py).

Related MCP server: AI-Pentest-MCP

See it work

That output is real — a scan of the deliberately vulnerable demo site that ships in this repo. Reproduce it in a minute:

python examples/demo_site.py &                 # http://127.0.0.1:8961 — loopback only, fake secrets
fsv scan http://127.0.0.1:8961 --authorize
fsv web                                        # open the same scan in the dashboard

The cloud_storage check asks Amazon S3 whether the demo's bucket exists — that one request goes to AWS (read-only). Skip it with --no-external.

What it finds that checklists miss

Plenty of tools tell you a header is missing. The incidents that actually hurt organisations — including very well-run ones — are quieter, and they live where nobody is looking.

The problem

How FSV avoids crying wolf

Module

🪝

A DNS record outlived its project — anyone can claim the name and serve content from your domain

asks for the CNAME explicitly (an A lookup hides dangling aliases), follows the chain, and never treats a resolver error as "dangling"

takeover

🪣

A page loads a script from a bucket that no longer exists — whoever creates it controls your page

one max-keys=1 request; objects are never fetched, nothing is created

cloud_storage

✉️

SPF include: of an expired domain, SPF over the 10-lookup limit, a 512-bit DKIM key

skips all DNS checks (with an explanation) if the domain itself doesn't resolve

dns_security

🗺️

Source maps and hard-coded credentials shipped to every visitor

credentials are reported masked and are never tested

js_analysis

🧱

jQuery 3.3.1 / AngularJS 1.x / Vue 2 and PHP 8.1 past end of support

dated tables — flagged the day support ends; version read from the URL without downloading third-party files

js_libs · tech

⛓️

XSS + a session cookie without HttpOnly = account takeover

only chains whose every link was found on this scan

correlation

Details, and every false-positive guard: docs/DETECTIONS.md.

Attack paths

Real compromises are rarely one bug — they're two or three "medium" problems that line up. Scanners rate each in isolation, so the combination stays invisible until someone writes the incident report. FSV reads its own findings (sending nothing more) and, where a chain is actually present, adds a finding that names the links, tells the story step by step, and states the cheapest single fix that breaks it. If a link is triaged away, the chain steps aside automatically.

Chain

Why it is worse together

XSS + session cookie without HttpOnly

one crafted link = account takeover

no HSTS / no HTTPS + session cookie without Secure

session readable on any hostile network

takeover-able subdomain + session cookie scoped to the parent domain

whoever claims the subdomain receives your users' sessions

dangling SPF include + DMARC not enforcing

perfectly authenticated phishing as your domain

no SPF/DMARC enforcement at all

your domain can be spoofed

Dashboard

Liquid-glass UI with a live stepper (survives a page reload), the attack-path panel, OWASP breakdown, per-host risk trend, sort / module filters, bulk triage, one-click re-scan, keyboard navigation, scan comparison, and one-click export — reports or paste-ready fixes. Light and dark themes; no third-party requests.

Features

  • Finds the pages first — besides links: robots.txt, sitemaps, routes leaked by debug pages, and API paths quoted in your JavaScript; action-like paths are never requested. --seed for anything else.

  • A badge for your README — fsv badge <scan_id> writes a dated grade badge (FSV security | A · 2026-10-25); regenerate it from CI.

  • Fix packs — turn findings into nginx / Apache / Caddy / Express / DNS configuration (fsv fixes <scan> nginx). Only what was actually found; CSP is emitted report-only.

  • Notifications — --notify <webhook> (or FSV_WEBHOOK_URL) posts the grade and the worst findings to Slack, Discord or your own endpoint. Evidence is never included.

  • CI-ready — fsv.toml, baselines (gate only on new findings), --fail-on, SARIF for GitHub code scanning, and a ready-made GitHub Action.

  • Triage that sticks — false positive / accepted risk / fixed / confirmed, stored per host by stable fingerprint, re-applied to later scans, excluded from the score. Diff any two scans; per-host trend.

  • Evidence over guesses — exposure checks validate content (a .git/HEAD must look like one; an SPA that answers 200 to everything produces nothing). Every finding has a confidence, a CWE, an OWASP Top 10 (2021) category, impact and remediation.

  • Honest failure — a crashing module is counted, explained and logged; a target that never answered is flagged, not graded "clean".

  • Safe by construction — secrets masked at the source; cloud-metadata/link-local never reachable, loopback/RFC 1918 optionally blocked, on every lookup and redirect hop; dashboard CSRF/DNS-rebinding guard and token auth.

  • Extensible — a module is one class; drop a file in ~/.fsv/plugins or ship an entry-point package (docs/WRITING_MODULES.md). Bring your own JS-library advisories and EOL dates.

  • Fast & polite, hard to stall — async engine, shared HTTP client with cache, request coalescing, token-bucket rate limit, retries, size cap, time limit with partial results. A hanging endpoint costs one timeout per scan, not one per module; every response regex is linear-time. Tested against hostile local servers (redirect loops, 20 MB bodies, hangs, catch-all SPAs).

  • Five report formats — Markdown (OWASP-grouped), JSON, self-contained HTML, SARIF 2.1, CSV.

  • Local-first — results in a local SQLite file; the only optional third-party calls are listed in DEPLOYMENT.md.

Install

pip install fsv          # Python 3.11+  ·  pipx install fsv  keeps it isolated
fsv doctor               # checks Python, dependencies, DNS, database, plugins

From source: git clone https://github.com/twayst0/fsv && cd fsv && ./install.sh (or pip install -e .).

Requires Python 3.11+. Docker: see docs/DEPLOYMENT.md (docker compose up).

Usage

fsv scan example.com --authorize                       # full scan of a site you own
fsv scan example.com --authorize --profile passive     # read-only: no payloads sent
fsv scan example.com --authorize --profile deep        # thorough: hidden parameters, ~90 more files, more payload shapes (slower)
fsv scan example.com --authorize --profile full --max-time 3600   # exhaustive: 1000+ URLs, ~600 guessed paths, backup copies, boolean SQLi
fsv web                                                # dashboard → http://127.0.0.1:7474
# scope & tuning
fsv scan example.com --authorize --exclude "/admin/*,/logout" --max-urls 100 --max-time 900 --tag prod
fsv scan example.com --authorize --header "Authorization: Bearer X" --cookie "session=abc"    # authenticated
fsv scan example.com --authorize --ct-logs        # also ask Certificate Transparency (crt.sh) for subdomains*
fsv scan example.com --authorize --no-external    # skip modules that contact hosts other than the target
fsv scan example.com --authorize --proxy env      # behind a corporate proxy (HTTPS_PROXY); or --proxy http://host:3128

# reports & fixes
fsv scan example.com --authorize -o report.html   # .md .json .html .sarif .csv
fsv report <scan_id> --format fix-nginx           # or fix-apache fix-caddy fix-express fix-dns
fsv fixes  <scan_id> nginx -o nginx-fixes.md

# triage, history, diff
fsv findings <scan_id>
fsv triage <scan_id> <finding_id> false_positive --note "test endpoint"
fsv list --target example.com   ·   fsv diff <before_id> <after_id>   ·   fsv prune --keep 50

# ownership proof (for shared deployments)           # * sends the domain name to crt.sh
fsv verify example.com   ·   fsv verify example.com --check

fsv modules   ·   fsv doctor

In CI

# fsv.toml  (commit it; ${VAR} is read from the environment — never commit secrets)
[scan]
profile  = "balanced"
max_urls = 100
exclude  = ["/admin/*"]
max_time = 900
fail_on  = "high"
baseline = ".fsv-baseline.json"
[scan.headers]
Authorization = "Bearer ${FSV_API_TOKEN}"
fsv scan staging.example.com --authorize --write-baseline .fsv-baseline.json    # once: accept today's state
fsv scan staging.example.com --authorize                                         # every build: fails only on NEW high+ findings
# .github/workflows/security.yml
- uses: twayst0/fsv@v2.4.0          # pin a release tag (or a commit SHA)
  with:
    target: https://staging.example.com
    authorized: "true"          # you confirm you may test this target
    profile: balanced
    fail-on: high
    baseline: .fsv-baseline.json

SARIF is uploaded to GitHub code scanning; the HTML report and log are attached as an artifact.

FSV and OWASP ZAP

ZAP is the right tool for deep testing of an application's inputs — use it. FSV looks at what surrounds the application, where typical DAST scans don't go, and the two work well side by side:

Area

Typical DAST scan

FSV

DNS that outlived its project (dangling CNAME, unregistered targets)

out of scope

takeover

Buckets your pages load from that no longer exist

out of scope

cloud_storage

Scripts from compromised CDNs (polyfill.io 2024) or expired domains

out of scope

supply_chain

Email spoofing: SPF lookup limit, dead includes, DMARC, DKIM key size

out of scope

dns_security

Debug mode visible only on error pages (Django, Werkzeug, Ignition…)

partly

debug_mode

Several medium findings that add up to account takeover

listed separately

correlation attack paths

Fixes as server config, triage that persists, CI baselines, MCP

—

built in

Deep input fuzzing, authenticated spidering, scripted auth, JS-rendered apps

yes

basic

Modules (40)

FSV ships 40 modules — 34 passive, 6 active. Run fsv modules for the live list.

Module

Looks for

Kind

takeover

dangling CNAME / unclaimed SaaS resource / unregistered target domain

passive · site · ↗

cloud_storage

orphaned or publicly-listable S3 / GCS / Azure buckets referenced by the site

passive · url · ↗

dns_security

SPF (10-lookup limit, dead includes, +all), DMARC, DKIM key strength, MTA-STS, dead NS/MX, CAA, DNSSEC

passive · site

js_analysis

hard-coded credentials, exposed source maps, internal/non-prod hosts in client code

passive · url

js_libs

known-vulnerable & end-of-life JavaScript libraries

passive · url

supply_chain

scripts/styles from compromised or abandoned CDNs (polyfill.io, bootcdn, staticfile, rawgit) or from domains that are no longer registered

passive · url · ↗

debug_mode

framework debug mode in production (Django DEBUG=True, Werkzeug console, Rails, Laravel Ignition, Symfony, Express, ASP.NET) — seen on error pages a crawler never visits

passive · site

paths

~100 exposed files/endpoints, each content-validated (.git, .env, actuator, pprof, tfstate, backups…); deep: ~90 more + backups named after the host

passive · site

html_leaks

secrets / internal hosts in HTML comments, pre-filled password fields, trust-bearing hidden fields (role, price, is_admin)

passive · url

dom_sinks

DOM XSS (URL → innerHTML/eval/redirect), postMessage without origin check — static analysis of first-party JS

passive · url

well_known

OIDC/OAuth discovery (http endpoints, alg=none, implicit/password grants, no PKCE) and private/symmetric keys published in JWKS

passive · site

api_docs

reads exposed OpenAPI (unauthenticated & sensitive routes, HTTP servers, secrets); Swagger UI, GraphiQL, Playground

passive · site

https_redirect

does port 80 serve content / hop through another host over HTTP / never reach HTTPS; HSTS without includeSubDomains

passive · site

content_discovery

full: ~600 common directories/pages nothing links to (admin, backup, staging, uploads…), calibrated against catch-all servers

passive · site

backup_files

full: .bak / ~ / .old / .swp copies of every crawled script and config that serve source code as text

passive · url

robots_review

sensitive Disallow entries, (deep) whether they answer, staging hosts in the sitemap

passive · site

tech

stack fingerprint + end-of-life software from a dated table

passive · site

headers · csp_analyzer

security headers · deep CSP review

passive

ssl

certificate trust classified from OpenSSL (expired · self-signed · incomplete chain · hostname mismatch), key size, SHA-1, and TLS 1.0/1.1 the server really accepts

passive · site

cookies

Secure / HttpOnly / SameSite / parent-domain scope

passive

sri · mixed_content · clickjacking · form_security · csrf

page-level hygiene

passive

info_disclosure · dir_listing · http_methods · security_txt · waf_detect · graphql_introspection · jwt_analysis · subdomain

exposure & recon

passive

xss · sqli · ssti · open_redirect · cors · host_header_injection

reflected/error-based/marker checks (benign payloads). XSS is context-aware (HTML text, attribute, JS string); SQLi reports only errors the injection caused

active

↗ contacts hosts other than the target (skip with --no-external). passive = sends no crafted payloads. Profiles: passive (only passive modules), balanced (default), aggressive (higher rate/concurrency), deep (wider crawl, hidden-parameter discovery, larger exposed-file list, more payload shapes — slower), full (everything in deep, then exhaustive: 1000+ URLs at depth 6, ~600 guessed paths, backup copies, boolean SQLi, 160 parameter names — slowest).

How it works

One engine, four front doors. Address policy and proof of control live in the engine, so every front door gets them; request guard and token auth belong to the web server. See docs/ARCHITECTURE.md.

Variable

Default

Purpose

FSV_HOST / FSV_PORT

127.0.0.1 / 7474

dashboard bind address

FSV_DB

~/.fsv/scans.db

SQLite database

FSV_TOKEN

—

shared secret required on every API / WebSocket call (X-FSV-Token or ?token=)

FSV_ALLOWED_HOSTS

—

extra Host names the dashboard answers to (DNS-rebinding guard)

FSV_BLOCK_PRIVATE

off

refuse loopback / RFC 1918 targets (SSRF protection). Cloud-metadata ranges are always refused

FSV_REQUIRE_VERIFICATION

off

payload-sending scans only against hosts whose owner proved control

FSV_MAX_SCANS

3

concurrent scans

FSV_DISABLED_MODULES

—

comma-separated module names to turn off

FSV_WEBHOOK_URL / FSV_WEBHOOK_MIN_SEVERITY

— / high

POST a short summary (Slack/Discord-compatible) when a scan finds issues at or above that severity; same as --notify URL

FSV_PLUGIN_DIR / FSV_NO_PLUGINS

~/.fsv/plugins / off

plugin discovery

FSV_ADVISORY_FILE / FSV_EOL_FILE

—

your own JS-library advisories / end-of-life dates (JSON)

Limits — what FSV is not

  • It reads HTML; it does not execute JavaScript, so content that only exists after client-side rendering isn't discovered.

  • Active checks cover common reflected classes with benign markers. It is not a replacement for a penetration test, SAST or an SCA pipeline.

  • The JS-advisory and end-of-life tables are curated snapshots — cross-check with OSV / endoflife.date for anything important, and extend them with the files above.

  • DNS checks are only as good as the resolver (fsv doctor tests it). A resolver that can't answer produces no DNS findings, not bad ones.

  • Findings carry a confidence; tentative ones are hints. Triage them, and tell us about false positives — they're the most useful bug reports.

Documentation

Detections · Architecture · Writing modules · Deploying safely · Security policy · Contributing · Changelog

The animated SVGs and screenshots above are generated from a real scan: scripts/build_readme_assets.sh --screenshots.

Contact

twayst0 (tways) — author and maintainer

Questions, collaboration and licensing enquiries are welcome by email or Discord.

License

MIT — free to use, modify and share, for anyone, including commercially. Keep the copyright and licence notice. Copyright © 2026 twayst0. See LICENSE.

Disclaimer

This software is provided "as is", for lawful, authorized security testing only. The authors accept no liability for misuse or damage. Always obtain written permission before testing any system you do not own.

Available Tools

12 tools
fsv_compare_scansA

Compare two scans by scan_id (e.g. before vs after a fix). Reports which findings were resolved, which are new, which persist, the risk-score delta and an improved/regressed verdict. Triaged-away findings are excluded, so false positives don't skew the diff.

Inputs: current_id (required), baseline_id (required). Returns: result

fsv_fixesA

Turn a scan's findings into paste-ready remediation for one platform: 'nginx', 'apache', 'caddy', 'express' (helmet/cookies) or 'dns' (SPF/DMARC/CAA records, dangling-record removal). Only issues actually found produce a snippet; CSP is emitted report-only. Show the user the snippets and remind them to test on staging.

Inputs: server (required), scan_id (required). Returns: result

fsv_get_reportA

Get a formatted report for a completed scan. format: 'md' (default, OWASP-grouped), 'json', 'html' (self-contained), 'sarif' (for CI/code-scanning), 'csv', or 'fix-nginx' / 'fix-apache' / 'fix-caddy' / 'fix-express' / 'fix-dns'.

Inputs: scan_id (required), format. Returns: result

fsv_list_modulesA

List all FSV scan modules with their category (passive/active), scope (site/url) and what each checks, plus the available scan profiles.

Inputs: no named parameters. Returns: result

fsv_list_scansB

List recent scans with IDs, targets, status, risk grade and finding counts. Optionally filter by target host substring.

Inputs: limit, target. Returns: result

fsv_quick_checkA

Fast passive check of a single URL — no payloads sent. Runs security headers, SSL/TLS, cookies, clickjacking, CSP review, SRI, WAF/CDN detection, technology fingerprint, DNS (SPF/DMARC), HTTP methods, security.txt, and JWT analysis. Safe for a first look. Pass authorized=true after the user confirms authorization.

Inputs: target (required), authorized (required). Returns: result

fsv_scanA

Run a web vulnerability scan against a target URL. Crawls the site (same-origin, skips logout/asset links) and runs modules by profile: 'passive' sends no payloads (headers, SSL/TLS, DNS, cookies, WAF, fingerprint, JWT, CSP, SRI, security.txt); 'balanced' (default) adds safe active checks (XSS, SQLi, CORS, open-redirect, SSTI, host-header); 'aggressive' is the same modules at higher rate/concurrency; 'deep' is thorough (wider crawl, hidden-parameter discovery, larger exposed-file list, more payload shapes — many more requests, only for targets the user owns); 'full' is exhaustive (1000+ URLs at depth 6, ~600 guessed directories/pages, backup copies of every script, boolean SQLi, 160 parameter names — the slowest and busiest; always set max_minutes). Returns findings grouped with severity, CWE, OWASP category, confidence and remediation. Time-boxed by max_minutes (default 20; partial results are kept). use_ct_logs=true also asks Certificate Transparency logs (crt.sh) for subdomains (sends the domain to a third party — only with the user's consent); allow_external=false skips modules that contact hosts other than the target. seed_urls adds same-origin pages no link points to; headers/cookies make it an authenticated scan (use a test account, never a real user's session). Only scan targets the user owns or is authorized to test; pass authorized=true only after they confirm.

Inputs: target (required), authorized (required), crawl, depth, +10 more. Returns: result

fsv_scan_statsC

Get the HTTP statistics of a scan (requests, cache hits, coalesced requests, retries, errors, status-code breakdown, average latency).

Inputs: scan_id (required). Returns: result

fsv_target_trendB

Show the risk-score trend for a host across its scan history (oldest first) — useful for reporting whether a site's posture is improving over time.

Inputs: target (required), limit. Returns: result

fsv_triageA

Record a triage decision for a finding so it persists across future scans of the same host. status: 'confirmed', 'false_positive', 'accepted_risk', 'fixed', or 'open' (clears it). false_positive / accepted_risk / fixed are excluded from the risk score. Identify the finding by its id or fingerprint from a scan result.

Inputs: status (required), finding (required), scan_id (required), note. Returns: result

fsv_verify_ownershipA

Prove control of a host so payload-sending scans are allowed on deployments that require it (FSV_REQUIRE_VERIFICATION=1). check=false returns the DNS TXT record / HTTP file to publish; check=true looks for it and records the proof.

Inputs: host (required), check. Returns: result

fsv_waf_checkA

Detect whether a target sits behind a Web Application Firewall or CDN (Cloudflare, AWS WAF, Akamai, Imperva, Sucuri, F5, ModSecurity, Fastly, …). Passive, single request. Pass authorized=true after the user confirms.

Inputs: target (required), authorized (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 12 tools

    Disambiguation4/5

    Most tools have clearly distinct roles: scanning, listing, comparing, triage, reporting, verification, and trend analysis are well separated. There is some overlap between fsv_quick_check and a passive fsv_scan, between fsv_waf_check and WAF detection included elsewhere, and between fsv_fixes and fsv_get_report's fix-* formats, but the descriptions clarify intended usage.

    Naming Consistency4/5

    All tools use a consistent fsv_ prefix and snake_case, with mostly verb_noun patterns such as fsv_list_scans, fsv_compare_scans, and fsv_get_report. A few are noun-only or less action-oriented (fsv_triage, fsv_fixes, fsv_target_trend), but the overall convention remains predictable.

    Tool Count5/5

    At 12 tools, the set is well-scoped for a vulnerability scanner: core scanning, reporting, history, triage, remediation, and verification each have a clear place. No tool appears redundant enough to inflate the count.

    Completeness5/5

    The surface covers the full scanning lifecycle: quick and full scans, scan listing and comparison, trend reporting, triage persistence, remediation snippets, stats, module discovery, WAF detection, ownership verification, and multiple report formats. No obvious operational gap stands out for the stated domain.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to perform authorized security testing and penetration testing operations including SSL/TLS analysis, port scanning, vulnerability scanning, and HTTP security header audits through natural language interactions.
      1
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables natural-language-driven security testing by orchestrating multiple pen-testing tools through MCP, with automated scan execution and AI-assisted vulnerability summarization.
      -
    • F
      license
      A
      quality
      D
      maintenance
      Enables AI assistants to perform defensive security tasks such as vulnerability detection, CVE lookup, phishing/link safety checks, and security report generation via MCP tools.
      23
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI assistants to drive OWASP ZAP for authorized penetration testing and bug-bounty workflows, including authenticated scans and vulnerability triage through 67 curated safety-gated tools.
      MIT