FSV
FSV's MCP server lets an AI assistant scan websites you're authorized to test, triage what it finds, and generate fixes — all from the chat client.
Scan a target (
fsv_scan) with profiles from passive (no payloads) to full/exhaustive, controlling depth, URL/path scope, seed URLs, time box, authenticated headers/cookies, and whether external hosts or Certificate Transparency logs are contacted (requiresauthorized=true).Get a quick first look (
fsv_quick_check) — a fast, payload-free check of headers, TLS, cookies, CSP, SRI, WAF, tech fingerprint, DNS and JWT.Detect a WAF/CDN (
fsv_waf_check) with a single passive request.Pull reports (
fsv_get_report) as Markdown, JSON, self-contained HTML, SARIF, CSV, or paste-ready fix packs.Generate remediation (
fsv_fixes) for nginx, Apache, Caddy, Express, or DNS records based only on issues actually found.Review scan history (
fsv_list_scans,fsv_scan_stats) — past scans, IDs, grades, finding counts and HTTP request statistics.Track change over time (
fsv_compare_scans,fsv_target_trend) — resolved vs. new findings, risk-score delta, and per-host risk trend.Triage findings (
fsv_triage) as confirmed, false positive, accepted risk or fixed, persisting per host and excluded from scoring.Prove target ownership (
fsv_verify_ownership) via DNS TXT or HTTP file when a deployment requires it before active scans.Discover capabilities (
fsv_list_modules) — every module, its category/scope, and available scan profiles.
Checks whether referenced cloud storage buckets exist on Amazon S3 using a read-only request, enabling detection of orphaned buckets used as script sources.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@FSV run a security review on https://my-shop.example, I own it"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
⚠ 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 pasteNo 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 |
| Full scan — profiles, scope, time-box, |
| Passive posture check / WAF-CDN detection |
| Paste-ready nginx / apache / caddy / express / DNS remediation |
| md · json · html · sarif · csv · |
| Mark false positive / accepted / fixed (persists per host) |
| Before/after a fix · risk over time |
| Proof of control (DNS TXT or HTTP file) for shared deployments |
| 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 dashboardThe 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" |
|
🪣 | A page loads a script from a bucket that no longer exists — whoever creates it controls your page | one |
|
✉️ | SPF | skips all DNS checks (with an explanation) if the domain itself doesn't resolve |
|
🗺️ | Source maps and hard-coded credentials shipped to every visitor | credentials are reported masked and are never tested |
|
🧱 | 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 |
|
⛓️ | XSS + a session cookie without HttpOnly = account takeover | only chains whose every link was found on this scan |
|
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.
--seedfor 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>(orFSV_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/HEADmust 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/pluginsor 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, pluginsFrom 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 doctorIn 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.jsonSARIF 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 |
|
Buckets your pages load from that no longer exist | out of scope |
|
Scripts from compromised CDNs (polyfill.io 2024) or expired domains | out of scope |
|
Email spoofing: SPF lookup limit, dead includes, DMARC, DKIM key size | out of scope |
|
Debug mode visible only on error pages (Django, Werkzeug, Ignition…) | partly |
|
Several medium findings that add up to account takeover | listed separately |
|
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 |
| dangling CNAME / unclaimed SaaS resource / unregistered target domain | passive · site · ↗ |
| orphaned or publicly-listable S3 / GCS / Azure buckets referenced by the site | passive · url · ↗ |
| SPF (10-lookup limit, dead includes, | passive · site |
| hard-coded credentials, exposed source maps, internal/non-prod hosts in client code | passive · url |
| known-vulnerable & end-of-life JavaScript libraries | passive · url |
| scripts/styles from compromised or abandoned CDNs (polyfill.io, bootcdn, staticfile, rawgit) or from domains that are no longer registered | passive · url · ↗ |
| framework debug mode in production (Django | passive · site |
| ~100 exposed files/endpoints, each content-validated ( | passive · site |
| secrets / internal hosts in HTML comments, pre-filled password fields, trust-bearing hidden fields (role, price, is_admin) | passive · url |
| DOM XSS (URL → innerHTML/eval/redirect), | passive · url |
| OIDC/OAuth discovery (http endpoints, | passive · site |
| reads exposed OpenAPI (unauthenticated & sensitive routes, HTTP servers, secrets); Swagger UI, GraphiQL, Playground | passive · site |
| does port 80 serve content / hop through another host over HTTP / never reach HTTPS; HSTS without | passive · site |
| full: ~600 common directories/pages nothing links to (admin, backup, staging, uploads…), calibrated against catch-all servers | passive · site |
| full: | passive · url |
| sensitive | passive · site |
| stack fingerprint + end-of-life software from a dated table | passive · site |
| security headers · deep CSP review | passive |
| 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 |
| Secure / HttpOnly / SameSite / parent-domain scope | passive |
| page-level hygiene | passive |
| exposure & recon | passive |
| 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 |
|
| dashboard bind address |
|
| SQLite database |
| — | shared secret required on every API / WebSocket call ( |
| — | extra |
| off | refuse loopback / RFC 1918 targets (SSRF protection). Cloud-metadata ranges are always refused |
| off | payload-sending scans only against hosts whose owner proved control |
|
| concurrent scans |
| — | comma-separated module names to turn off |
| — / | POST a short summary (Slack/Discord-compatible) when a scan finds issues at or above that severity; same as |
|
| plugin discovery |
| — | 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 doctortests 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
Email: statways1707@gmail.com
Discord: .tways
Security issues: please report privately (see SECURITY.md), not in a public issue.
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 toolsfsv_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
Scored across 12 tools
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.
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.
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.
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
Related MCP Connectors
Authorized security scans, evidence, fix prompts and retests for AI-built web apps.
Scan websites and code for security, performance and SEO issues from your AI assistant.
Security, SEO and AI-visibility scanner for web apps · free scans and focused checks via MCP.
AI pentesting: run scans, triage vulnerabilities, review PRs, manage schedules and assets.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables 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.1MIT
- FlicenseNot gradedqualityDmaintenanceEnables natural-language-driven security testing by orchestrating multiple pen-testing tools through MCP, with automated scan execution and AI-assisted vulnerability summarization.-
- FlicenseAqualityDmaintenanceEnables 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-
- AlicenseNot gradedqualityBmaintenanceEnables 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