Skip to main content
Glama

The Problem

Fingerprinting a server today means juggling a dozen disconnected tools. You run nmap for port scanning, testssl.sh for certificate analysis, curl -I for HTTP headers, dig for DNS, wafw00f for WAF detection, ssh-audit for SSH, a separate JARM tool, Wappalyzer for tech detection — and then you spend 30 minutes manually cross-referencing everything in a spreadsheet to figure out what's actually running.

Traditional fingerprinting workflow:
  analyze TLS certificates     ->  testssl.sh / openssl s_client
  grab HTTP headers            ->  curl -I
  detect web technologies      ->  wappalyzer CLI
  DNS reconnaissance           ->  dig / nslookup / dnsenum
  port scanning                ->  nmap -sV
  WAF detection                ->  wafw00f
  SSH audit                    ->  ssh-audit
  service fingerprinting       ->  nmap scripts
  JARM fingerprint             ->  jarm (separate tool)
  check OSINT databases        ->  shodan CLI, censys CLI
  correlate everything         ->  manually in a spreadsheet
  ──────────────────────────────
  Total: 11 tools, 30+ minutes, manual correlation

fingerprint-mcp gives your AI agent 13 composite tools wrapping 103 fingerprinting techniques across 21 providers via the Model Context Protocol. The agent runs multi-layer fingerprinting in parallel, correlates signals across TCP/TLS/HTTP/DNS/SSH layers, detects honeypots and C2 infrastructure, and presents a unified intelligence picture — in a single conversation.

With fingerprint-mcp:
  You: "Do a deep recon on target.com"

  Agent: -> recon {url: "https://target.com", depth: "deep"}

         -> TLS: nginx/1.24.0 via JARM (3fd21b20d00000...),
            Let's Encrypt cert, 2 SANs, TLS 1.2+1.3
         -> HTTP: Express.js behind Cloudflare WAF,
            React SPA, Google Analytics, 14 security headers analyzed
         -> DNS: A/AAAA/MX/TXT records, SPF/DKIM/DMARC configured,
            Slack + Google Workspace detected via CNAME/MX
         -> Ports: 80, 443, 22 (OpenSSH 9.6), 8080 (dev server)
         -> WAF: Cloudflare detected, origin IP discovered via direct-connect
         -> Enumeration: 12 subdomains via CT logs, wildcard DNS detected
         -> "target.com runs nginx/1.24.0 with Express.js behind
            Cloudflare WAF. Origin IP 203.0.113.42 exposed on port 8080.
            TLS is properly configured (A+ equivalent) but the dev server
            on 8080 has no WAF protection. 3 subdomains point to
            decommissioned infrastructure — potential takeover risk."

Related MCP server: OSINT Tools MCP Server

How It's Different

Existing tools give you raw data one layer at a time. fingerprint-mcp gives your AI agent the ability to reason across all fingerprinting layers simultaneously.


Quick Start

Option 1: npx (no install)

npx fingerprint-mcp

All 80+ active fingerprinting techniques work immediately. No API keys required for TCP, TLS, SSH, HTTP, DNS, WAF, path, service, timing, IoT, SMTP, infrastructure, and application fingerprinting.

Option 2: Clone

git clone https://github.com/badchars/fingerprint-mcp.git
cd fingerprint-mcp
bun install

Environment variables (optional)

# OSINT enrichment (all optional — active fingerprinting works without any keys)
export SHODAN_API_KEY=your-key           # Enables osint_shodan, ssh_hostkey_lookup
export CENSYS_API_ID=your-id             # Enables osint_censys (free: 250 queries/month)
export CENSYS_API_SECRET=your-secret     # Censys API secret
export SECURITYTRAILS_API_KEY=your-key   # Enables waf_origin, enum_passive_dns
export VIRUSTOTAL_API_KEY=your-key       # Enables osint_virustotal (free: 500 queries/day)

All API keys are optional. Without them, you still get full TCP/TLS/SSH/HTTP/DNS/WAF/path/service/timing/IoT/SMTP/infrastructure/application fingerprinting, correlation, passive analysis, enumeration, and meta tools — 80+ techniques that work by directly probing the target.

Connect to your AI agent

# With npx
claude mcp add fingerprint-mcp -- npx fingerprint-mcp

# With local clone
claude mcp add fingerprint-mcp -- bun run /path/to/fingerprint-mcp/src/index.ts

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "fingerprint": {
      "command": "npx",
      "args": ["-y", "fingerprint-mcp"],
      "env": {
        "SHODAN_API_KEY": "optional",
        "CENSYS_API_ID": "optional",
        "CENSYS_API_SECRET": "optional",
        "SECURITYTRAILS_API_KEY": "optional",
        "VIRUSTOTAL_API_KEY": "optional"
      }
    }
  }
}

Same JSON config format. Point the command to npx fingerprint-mcp or your local installation path.

Start querying

You: "Fingerprint everything about target.com — TLS, HTTP stack, WAF, DNS, open ports"

That's it. The agent handles multi-layer fingerprinting, signal correlation, and infrastructure analysis automatically.


What The AI Can Do

Quick Recon

You: "Quick recon on target.com"

Agent: -> recon {url: "https://target.com", depth: "quick"}

       -> TCP: ports 80, 443, 22 open
       -> TLS: Let's Encrypt RSA cert, TLS 1.2+1.3, nginx JARM signature
       -> HTTP: nginx/1.24.0, Express.js, React, Cloudflare CDN
       -> DNS: A 203.0.113.42, MX Google Workspace, SPF/DKIM configured
       -> WAF: Cloudflare detected (cf-ray header)
       -> "target.com is a React SPA on Express.js behind nginx/1.24.0,
          served through Cloudflare CDN. TLS properly configured with
          Let's Encrypt. SSH on port 22 running OpenSSH 9.6. Email
          handled by Google Workspace with full SPF/DKIM/DMARC."

Deep TLS Investigation

You: "Analyze the TLS configuration of suspicious-server.com in detail"

Agent: -> scan_tls {host: "suspicious-server.com"}

       -> Certificate: self-signed, CN=localhost, expired 47 days ago
       -> JARM: 2ad2ad0002ad2ad00042d42d00000069d641f34fe76acdc05c40262f8815e5
          (matches Cobalt Strike default profile)
       -> JA4X: fingerprint matches known C2 framework pattern
       -> Cipher suites: accepts weak ciphers (RC4, 3DES)
       -> SNI: responds identically to any SNI value
       -> CT logs: certificate not logged (not publicly trusted)
       -> "HIGH RISK: TLS configuration strongly indicates C2 infrastructure.
          Self-signed expired cert, JARM fingerprint matches Cobalt Strike,
          accepts weak ciphers, and responds to arbitrary SNI values.
          Recommend immediate investigation and blocking."

WAF Bypass & Origin Discovery

You: "target.com is behind a WAF. Can you find the origin server?"

Agent: -> scan_waf {url: "https://target.com"}
       -> scan_dns {domain: "target.com"}
       -> enumerate {domain: "target.com"}

       -> WAF: Cloudflare (AS13335), challenge page on suspicious requests
       -> DNS: A record points to Cloudflare IP 104.21.x.x
       -> Subdomains: dev.target.com resolves to 203.0.113.42 (non-Cloudflare)
       -> Direct connect to 203.0.113.42:443 returns same TLS cert
       -> SecurityTrails historical: origin was 203.0.113.42 before Cloudflare
       -> "Origin IP found: 203.0.113.42. Discovered via dev.target.com
          subdomain which bypasses Cloudflare. The origin serves the same
          TLS certificate and responds to the target.com Host header.
          Origin has no WAF protection — direct access possible."

Service Discovery on a Host

You: "What services are running on 10.0.1.50?"

Agent: -> scan_ports {host: "10.0.1.50"}
       -> scan_services {host: "10.0.1.50", ports: [22, 80, 3306, 5432, 6379, 8080]}

       -> Port 22: OpenSSH 8.9p1 Ubuntu, ED25519 host key
       -> Port 80: Apache/2.4.57, PHP/8.2, WordPress 6.4
       -> Port 3306: MySQL 8.0.36, authentication required
       -> Port 5432: PostgreSQL 16.1, SSL required
       -> Port 6379: Redis 7.2.4, NO authentication (open)
       -> Port 8080: Node.js Express dev server, CORS: *
       -> "CRITICAL: Redis on port 6379 has no authentication — anyone on
          the network can read/write data. The Express dev server on 8080
          has wildcard CORS. MySQL and PostgreSQL properly require auth.
          WordPress is 2 minor versions behind. Immediate action needed
          on Redis and the dev server exposure."

Tools Reference (13 tools, 103 techniques)

Parameter

Type

Description

url

string

Target URL to fingerprint

depth

quick | standard | deep

Scan depth: quick=5 techniques, standard=20, deep=50+

Orchestrates techniques from all providers based on depth level. Quick mode gives a fast overview; deep mode runs exhaustive fingerprinting including enumeration, OSINT, and correlation.

Parameter

Type

Description

host

string

Target host (IP or domain)

ports

number[]

Optional — specific ports to scan (defaults to common ports)

Technique

Description

tcp_probe

TCP connect scan to detect open ports

tcp_banner

Banner grabbing on open ports for service identification

tcp_analysis

Port combination analysis and service inference

Parameter

Type

Description

host

string

Target host (IP or domain)

port

number

Optional — TLS port (default: 443)

Technique

Description

tls_certificate

X.509 certificate parsing — subject, issuer, SANs, validity, chain

tls_jarm

JARM active fingerprinting — 10 TLS Client Hello probes, 62-char hash

tls_ja4x

JA4X passive TLS fingerprinting from certificate properties

tls_ciphers

Cipher suite enumeration and strength analysis

tls_protocols

Supported TLS protocol version detection (SSLv3 through TLS 1.3)

tls_sni

SNI behavior testing — default cert vs. requested hostname

tls_ct_logs

Certificate Transparency log lookup via crt.sh

tls_ocsp

OCSP stapling and revocation status check

Parameter

Type

Description

domain

string

Target domain

Technique

Description

dns_records

Full record enumeration — A, AAAA, MX, NS, TXT, CNAME, SOA

dns_email_auth

SPF, DKIM, and DMARC record analysis

dns_saas

SaaS/service detection via CNAME and MX patterns (Slack, Zendesk, etc.)

dns_server

DNS server fingerprinting (BIND, PowerDNS, Cloudflare, etc.)

dns_takeover

Subdomain takeover detection via dangling CNAME analysis

dns_zone

Zone transfer attempt (AXFR)

dns_caa

CAA record analysis for certificate authority restrictions

Parameter

Type

Description

url

string

Target URL

Technique

Provider

Description

http_headers

HTTP

Response header analysis and server identification

http_header_order

HTTP

Header ordering fingerprint (server software signature)

http_security_headers

HTTP

Security header audit (CSP, HSTS, X-Frame-Options, etc.)

http_cookies

HTTP

Cookie analysis — flags, prefixes, framework detection

http_methods

HTTP

Allowed HTTP method enumeration (OPTIONS)

http_cors

HTTP

CORS policy analysis and misconfiguration detection

http_compression

HTTP

Supported compression algorithms (gzip, br, zstd)

http_caching

HTTP

Cache header analysis (CDN, reverse proxy detection)

http_etag

HTTP

ETag format analysis for backend identification

http_error

HTTP

Error page fingerprinting (custom vs. default error pages)

http_redirect

HTTP

Redirect chain analysis

http_timing

HTTP

Response timing baseline for server performance profiling

http_favicon

HTTP

Favicon hash (MurmurHash3) for technology identification

http_robots

HTTP

robots.txt parsing and disallowed path extraction

http_sitemap

HTTP

Sitemap discovery and URL extraction

http_wellknown

HTTP

.well-known endpoint discovery (security.txt, openid, etc.)

web_tech

Web

Technology detection via HTML/JS/CSS patterns

web_analytics

Web

Analytics and tracking service detection

web_sourcemaps

Web

Source map file discovery

web_websocket

Web

WebSocket endpoint detection

web_graphql

Web

GraphQL endpoint detection and introspection

web_spa

Web

Single-page application framework detection

web_cdn

Web

CDN detection via response headers and DNS

web_meta

Web

HTML meta tag analysis (generator, framework hints)

web_feed

Web

RSS/Atom feed discovery

h2_detect

HTTP/2

HTTP/2 protocol support detection

h2_fingerprint

HTTP/2

HTTP/2 server fingerprinting (SETTINGS, WINDOW_UPDATE)

h2_h3

HTTP/2

HTTP/3 (QUIC) support detection via Alt-Svc header

app_cms

Application

CMS detection (WordPress, Drupal, Joomla, etc.)

Parameter

Type

Description

url

string

Target URL

categories

string[]

Optional — categories to check (sensitive, git, debug, api, config)

Technique

Description

path_sensitive

Sensitive file discovery (backup files, config files, database dumps)

path_robots

robots.txt and sitemap.xml analysis for hidden paths

path_git

Git repository leak detection (.git/HEAD, .git/config)

path_debug

Debug endpoint discovery (phpinfo, server-status, debug consoles)

path_api

API version and documentation endpoint discovery

Parameter

Type

Description

url

string

Target URL

Technique

Description

waf_detect

WAF presence detection via response header and behavior analysis

waf_cdn

CDN provider identification (Cloudflare, Akamai, Fastly, etc.)

waf_fingerprint

WAF product identification and version detection

waf_origin

Origin IP discovery behind WAF/CDN (requires SECURITYTRAILS_API_KEY)

Parameter

Type

Description

host

string

Target host (IP or domain)

ports

number[]

Optional — specific ports to probe

service

string

Optional — specific service to probe (mysql, postgres, redis, ftp, ssh, smtp, vnc, iot)

Technique

Provider

Description

ssh_probe

SSH

SSH protocol version and software detection

ssh_algorithms

SSH

SSH algorithm audit (KEX, ciphers, MACs, host key types)

ssh_hostkey_lookup

SSH

SSH host key lookup via Shodan (requires SHODAN_API_KEY)

svc_mysql

Service

MySQL version detection and capability fingerprinting

svc_postgres

Service

PostgreSQL version detection and SSL support check

svc_redis

Service

Redis version detection and authentication status

svc_ftp

Service

FTP banner analysis and anonymous login check

svc_vnc_rdp

Service

VNC/RDP service detection and security assessment

smtp_banner

SMTP

SMTP banner analysis and MTA identification

smtp_starttls

SMTP

SMTP STARTTLS support and certificate inspection

iot_detect

IoT

IoT device detection via banner patterns and default pages

iot_upnp

IoT

UPnP/SSDP device discovery on local network

Parameter

Type

Description

domain

string

Target domain

Technique

Description

enum_subdomains

Subdomain enumeration via multiple methods

enum_wildcard

Wildcard DNS detection

enum_tld

TLD expansion (target.com -> target.net, target.org, etc.)

enum_related

Related domain discovery via shared infrastructure

enum_asn

ASN neighbor discovery — other domains on same network

enum_ct

Certificate Transparency log subdomain extraction

enum_passive_dns

Passive DNS history (requires SECURITYTRAILS_API_KEY)

enum_scope

Scope summary and attack surface overview

Parameter

Type

Description

target

string

IP address or domain to enrich

type

ip | domain

Optional — target type (auto-detected if omitted)

Technique

Auth

Description

osint_shodan

SHODAN_API_KEY

Shodan host lookup — open ports, banners, vulns, OS

osint_censys

CENSYS_API_ID + CENSYS_API_SECRET

Censys host data — services, TLS, autonomous system

osint_reverse_ip

None

Reverse IP lookup — other domains on same IP

osint_whois

None

WHOIS registration data — registrar, dates, nameservers

osint_webarchive

None

Web Archive history — first/last snapshot, change frequency

osint_virustotal

VIRUSTOTAL_API_KEY

VirusTotal domain/IP report — detections, categories, DNS

Parameter

Type

Description

type

headers | html | banner

Type of data to analyze

data

string

Raw data to analyze (paste headers, HTML, or banner output)

Mode

Description

fp_analyze_headers

Passive HTTP header analysis — server, framework, proxy detection without sending traffic

fp_analyze_html

Passive HTML analysis — technology detection, framework identification from source

fp_analyze_banner

Passive banner analysis — service identification from raw banner text

Parameter

Type

Description

type

consistency | honeypot | spoofing | compare | topology | c2 | identify

Correlation mode

signals

object

Fingerprint signals to correlate (varies by mode)

Mode

Description

fp_consistency

Cross-layer signal consistency check — do TCP, TLS, HTTP, and DNS fingerprints agree?

fp_honeypot

Honeypot detection — checks for impossible service combinations and behavioral anomalies

fp_spoofing

Spoofing detection — identifies mismatched server headers vs. actual behavior

fp_compare

Side-by-side comparison of two hosts' fingerprint profiles

fp_topology

Infrastructure topology mapping — CDN, load balancer, reverse proxy chain

fp_c2

C2 framework detection via JARM, TLS, HTTP, and timing correlation

fp_identify

Hash-based identification against known signature database

Parameter

Type

Description

category

string

Optional — filter by category

Mode

Description

fp_sources

List all available data sources with configuration and API key status

fp_config

Server configuration — version, loaded providers, technique count

fp_signatures

Signature database listing — JARM, banner, WAF, application signatures


CLI Usage

# List all available tools and techniques
npx fingerprint-mcp --list

# Run any tool directly
npx fingerprint-mcp --tool recon '{"url":"https://example.com","depth":"quick"}'
npx fingerprint-mcp --tool scan_tls '{"host":"example.com"}'
npx fingerprint-mcp --tool scan_ports '{"host":"10.0.1.50","ports":[22,80,443,3306,8080]}'
npx fingerprint-mcp --tool scan_dns '{"domain":"example.com"}'
npx fingerprint-mcp --tool scan_http '{"url":"https://example.com"}'
npx fingerprint-mcp --tool scan_waf '{"url":"https://example.com"}'
npx fingerprint-mcp --tool scan_services '{"host":"10.0.1.50","service":"redis"}'
npx fingerprint-mcp --tool enumerate '{"domain":"example.com"}'
npx fingerprint-mcp --tool analyze '{"type":"headers","data":"Server: nginx/1.24.0\nX-Powered-By: Express"}'
npx fingerprint-mcp --tool correlate '{"type":"honeypot","signals":{"jarm":"...","banner":"..."}}'
npx fingerprint-mcp --tool meta '{}'

# OSINT tools (require API keys)
SHODAN_API_KEY=your-key npx fingerprint-mcp --tool osint '{"target":"203.0.113.42","type":"ip"}'

Data Sources (21)

Source

Auth

What it provides

TCP probing

None

Port scanning, banner grabbing, service detection

TLS/SSL analysis

None

Certificate parsing, JARM fingerprinting, JA4X, cipher enumeration, SNI testing

SSH probing

None

Protocol version, algorithm audit, software detection

HTTP analysis

None

Header fingerprinting, favicon hashing, cookie analysis, method enumeration, CORS

Web detection

None

Technology detection, analytics, source maps, WebSocket, GraphQL, SPA frameworks

Path discovery

None

Sensitive files, git leaks, debug endpoints, API versions, robots.txt

DNS resolution

None

Record enumeration, email auth analysis, SaaS detection, server fingerprinting

WAF/CDN detection

None

WAF identification, CDN detection, WAF fingerprinting

Timing analysis

None

Response timing baseline, clock skew detection

HTTP/2 & HTTP/3

None

HTTP/2 detection and fingerprinting, HTTP/3 Alt-Svc discovery

SMTP probing

None

SMTP banner analysis, STARTTLS inspection

IoT/Embedded

None

IoT device detection, UPnP/SSDP discovery

Application detection

None

CMS, framework, and e-commerce platform identification

Service probing

None

MySQL, PostgreSQL, Redis, FTP, VNC/RDP fingerprinting

Infrastructure detection

None

Cloud provider, hosting provider, CDN identification

Correlation engine

None

Signal consistency, honeypot detection, spoofing detection, topology mapping

Identification engine

None

Hash-based identification, C2 detection, signature matching

Shodan

SHODAN_API_KEY

Host intelligence — open ports, banners, vulnerabilities, OS detection

Censys

CENSYS_API_ID

Host data — services, TLS certificates, autonomous system info

SecurityTrails

SECURITYTRAILS_API_KEY

WAF origin discovery, passive DNS history, historical records

VirusTotal

VIRUSTOTAL_API_KEY

Domain/IP reputation, detection results, DNS history, categories


Architecture

src/
  index.ts                # CLI entrypoint (--help, --list, --tool, stdio server)
  protocol/
    mcp-server.ts         # MCP server setup (stdio transport)
    tools.ts              # Tool registry — all 13 composite tools registered here
  types/
    index.ts              # Shared types (ToolDef, ToolContext, ToolResult)
  utils/
    rate-limiter.ts       # Per-provider rate limiter
    cache.ts              # TTL cache for API responses
    require-key.ts        # API key validation helper
    murmurhash3.ts        # MurmurHash3 for favicon hashing
  composite/              # 13 composite tool orchestrators
    recon.ts              # Full recon orchestrator (quick/standard/deep)
    scan-ports.ts         # Port scanning composite
    scan-tls.ts           # TLS analysis composite
    scan-dns.ts           # DNS intelligence composite
    scan-http.ts          # HTTP fingerprinting composite
    scan-paths.ts         # Path discovery composite
    scan-waf.ts           # WAF/CDN detection composite
    scan-services.ts      # Service probing composite
    analyze.ts            # Passive analysis composite
    correlate.ts          # Correlation engine composite
    enumerate.ts          # Scope expansion composite
    osint.ts              # OSINT enrichment composite
    meta.ts               # Server meta composite
    helpers.ts            # Shared composite helpers
  tcp/                    # TCP probing techniques (3)
  tls/                    # TLS/SSL analysis techniques (8)
  ssh/                    # SSH probing techniques (3)
  http/                   # HTTP fingerprinting techniques (16)
  web/                    # Web technology detection techniques (9)
  path/                   # Path discovery techniques (5)
  dns/                    # DNS intelligence techniques (7)
  waf/                    # WAF/CDN detection techniques (4)
  timing/                 # Timing analysis techniques (2)
  h2/                     # HTTP/2 & HTTP/3 techniques (3)
  smtp/                   # SMTP probing techniques (2)
  iot/                    # IoT/embedded detection techniques (2)
  app/                    # Application detection techniques (3)
  service/                # Service probing techniques (5)
  infra/                  # Infrastructure detection techniques (3)
  correlation/            # Correlation engine (5)
  identify/               # Identification engine (3)
  passive/                # Passive analysis (3)
  osint/                  # OSINT enrichment techniques (6)
  enum/                   # Enumeration techniques (8)
  meta/                   # Meta tools (3)
  data/                   # Signature databases and pattern libraries
    jarm-signatures.ts    # Known JARM fingerprints (C2, servers, CDNs)
    waf-signatures.ts     # WAF detection signatures
    service-banners.ts    # Service banner patterns
    tech-patterns.ts      # Technology detection patterns
    favicon-hashes.ts     # Known favicon MurmurHash3 values
    c2-signatures.ts      # C2 framework signatures
    ...                   # 15+ signature/pattern databases

Design decisions:

  • 13 composite tools, 103 techniques — The agent calls high-level tools (recon, scan_tls, scan_http). Each composite orchestrates multiple low-level techniques and returns correlated results. This reduces tool-call overhead while maintaining granularity.

  • 21 providers, 1 server — Every fingerprinting layer is an independent module. The composite orchestrator selects techniques based on context and depth.

  • Active-first, OSINT-optional — 80+ techniques work by directly probing the target with zero API keys. OSINT providers (Shodan, Censys, VirusTotal, SecurityTrails) add enrichment but are never required.

  • Per-provider rate limiters — Each provider has its own RateLimiter instance. Active probing is rate-limited to avoid detection; OSINT APIs are calibrated to their quotas.

  • TTL caching — DNS records (10min), OSINT results (15min), CT logs (30min) are cached to avoid redundant lookups during multi-tool workflows.

  • Graceful degradation — Missing API keys don't crash the server. OSINT tools return descriptive messages: "Set SHODAN_API_KEY to enable Shodan host lookup."

  • 3 dependencies — @modelcontextprotocol/sdk, zod, and cheerio. All network I/O via native fetch() and Node.js net/tls/dns modules. No nmap, no external binaries.


Limitations

  • OSINT tools (Shodan, Censys, VirusTotal, SecurityTrails) require API keys for their respective techniques

  • Censys free tier limited to 250 queries/month

  • VirusTotal free tier limited to 500 queries/day

  • Port scanning uses TCP connect (not SYN scan) — less stealthy than nmap but requires no root privileges

  • JARM fingerprinting requires direct TCP access to the target (may be blocked by firewalls)

  • UPnP/SSDP discovery only works on local networks

  • Service probing (MySQL, PostgreSQL, Redis) connects but does not authenticate

  • Subdomain enumeration relies on CT logs and passive sources (no brute-force)

  • macOS / Linux tested (Windows not tested)


Part of the MCP Security Suite

Project

Domain

Tools

hackbrowser-mcp

Browser-based security testing

39 tools, Firefox, injection testing

cloud-audit-mcp

Cloud security (AWS/Azure/GCP)

38 tools, 60+ checks

github-security-mcp

GitHub security posture

39 tools, 45 checks

cve-mcp

Vulnerability intelligence

23 tools, 5 sources

osint-mcp-server

OSINT & reconnaissance

37 tools, 12 sources

darknet-mcp-server

Dark web & threat intelligence

66 tools, 16 sources

fingerprint-mcp

Universal digital fingerprinting

13 tools, 103 techniques, 21 providers


Available Tools

13 tools
analyzeA

Passive analysis of pre-collected data. No network calls. Supports three modes: headers (HTTP header fingerprinting), html (HTML source analysis), banner (service banner identification).

ParametersJSON Schema
NameRequiredDescriptionDefault
urlNoURL context for headers/html analysis
htmlNoHTML source code (for type=html)
portNoPort number context for banner analysis
typeYesAnalysis type
bannerNoService banner string (for type=banner)
headersNoHTTP response headers (for type=headers)

TDQS

A3.8/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Without annotations, the description carries the full burden. It clearly states the tool is passive and makes no network calls, which is transparent. However, it does not disclose error handling, return format, or edge cases, which would be helpful for a multi-mode analysis tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise: two sentences that cover purpose, behavioral trait, and the three modes. Every word earns its place with no fluff or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has 6 parameters, nested objects, and no output schema, the description is too minimal. It does not explain what each analysis mode returns or provide guidance on expected output, which is necessary for an agent to use the tool effectively without external documentation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. The description reinforces the parameter roles by grouping them under the three modes, but does not add significant new meaning beyond the schema descriptions. It clarifies which parameters apply to which mode, which is helpful but not enough to raise the score.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool performs passive analysis of pre-collected data, which is a specific verb+resource. It also lists three distinct modes (headers, html, banner), effectively distinguishing it from sibling tools that likely involve active scanning or other operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description indicates the tool is for passive analysis without network calls, implying when to use it (pre-collected data). However, it does not explicitly mention when not to use it or suggest alternative tools, though the sibling context provides some implicit differentiation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

correlateC

Cross-layer correlation engine. Validates fingerprint consistency, detects honeypots, identifies spoofing, compares profiles, reconstructs infrastructure topology, detects C2 frameworks, and looks up fingerprint hashes.

ParametersJSON Schema
NameRequiredDescriptionDefault
hashNoFingerprint hash (for identify)
hostNoTarget host (for c2)
jarmNoJARM hash
portNoTarget port (for c2)
typeYesCorrelation type
hasshNoHASSH fingerprint
certCnNoCertificate CN (for c2)
certOrgNoCertificate Org (for c2)
cookiesNoCookie names
certSansNoCertificate SANs (for topology)
hashTypeNoHash type (for identify)
originIpNoOrigin IP (for topology)
profile1NoFirst profile (for compare)
profile2NoSecond profile (for compare)
servicesNoDetected services (for honeypot)
lbCookiesNoLB cookies (for topology)
sshBannerNoSSH banner
dnsRecordsNoDNS records (for topology)
tlsVersionNoTLS version
cdnProviderNoCDN provider (for topology)
headerOrderNoHeader ordering (for spoofing)
serverHeaderNoServer header value
openPortCountNoTotal open ports (for honeypot)
sshAlgorithmsNoSSH algorithms
certSelfSignedNoSelf-signed cert (for c2)
claimedVersionNoClaimed server version
errorSignatureNoError page signature
headerOrderHashNoHeader order hash
certValidityDaysNoCert validity days (for c2)
responseTimingMsNoResponse timing ms (for c2)
internalHostnamesNoInternal hostnames (for topology)

TDQS

C2.8/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description does not disclose behavioral traits such as read-only nature, authentication requirements, rate limits, or potential side effects. While the description implies analytic operations, it fails to clarify what happens with invalid inputs or whether it modifies any state.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that lists multiple capabilities side by side. It is concise but dense, making it harder to parse quickly. There is no use of structure (e.g., bullet points) to separate different correlation types. The core purpose is front-loaded, but the list is somewhat run-on.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has 31 parameters, complex nested schemas, and no output schema. The description does not explain return values, error handling, or how the 'type' field determines which parameters are relevant. Given the complexity and lack of annotations, the description is insufficient for selecting proper input combinations or interpreting results.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with each parameter clearly documented (including nested objects). The tool description adds no additional meaning beyond the schema's parameter descriptions. For each parameter, the schema already indicates its purpose (e.g., 'for c2', 'for topology'), so the description does not further enhance semantics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool is a 'Cross-layer correlation engine' and lists specific actions like validation, detection, comparison, topology reconstruction, and C2 detection. The verb 'correlate' with specific outcomes is well-defined, but it does not differentiate from sibling tools like 'analyze' or 'enumerate', which may overlap.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, data needed, or scenarios where other tools (e.g., scan_*) would be more appropriate. The description only lists capabilities without context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

enumerateA

Scope expansion: subdomain enumeration (SecurityTrails/HackerTarget), wildcard DNS detection, TLD/ccTLD expansion, related domain discovery via certificate transparency, ASN neighbor enumeration, passive DNS history, and attack surface summary. 8 techniques across 3 phases.

ParametersJSON Schema
NameRequiredDescriptionDefault
domainYesTarget domain for scope expansion

TDQS

A3.5/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must fully disclose behavioral traits. While the description mentions many techniques, it does not state whether the tool is destructive, requires authentication, has rate limits, or provides any output format details. This is a significant gap for a tool performing multiple phases of operations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with 'Scope expansion' but then lists 8 techniques in a verbose manner. While informative, it could be more concise. The summary '8 techniques across 3 phases' adds structure but the description overall feels slightly bloated for a parameter of one.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complex nature of the tool (8 techniques, 3 phases) and lack of output schema, the description provides a high-level overview of capabilities but omits details on phases, output format, or expected behavior. It partially compensates for missing annotations but is not fully complete for an agent to understand all aspects.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 100% coverage for the single 'domain' parameter with description 'Target domain for scope expansion'. The tool description adds additional meaning by listing the specific enumeration techniques applied, providing context that helps the agent understand the scope of operations, going beyond the simple schema description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: scope expansion through various enumeration techniques like subdomain enumeration, wildcard DNS detection, TLD expansion, etc. It uses specific verbs and clearly distinguishes from sibling tools such as scan_dns or analyze, which focus on scanning or analysis.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not explicitly state when to use this tool versus alternatives. While the context of 'scope expansion' implies it is for initial reconnaissance, there is no guidance on prerequisites or when not to use it, leaving the agent to infer usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

metaA

Server info: lists all providers, tools, configuration, and known signature databases in a single response.

ParametersJSON Schema
NameRequiredDescriptionDefault
categoryNoFilter by category: active, passive, osint, enum, analysis, meta

TDQS

A3.6/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It states the tool returns a listing, implying a read-only operation, but does not disclose any behavioral traits like authentication needs, rate limits, or potential side effects. The description is adequate but not detailed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that efficiently conveys the tool's purpose. It is front-loaded with 'Server info' and lists contents without unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the absence of annotations and output schema, the description provides a clear idea of what the tool returns. It mentions all key categories (providers, tools, configuration, signature databases). However, it lacks details on output structure or pagination, which would be beneficial for a meta tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. The description does not add any meaning beyond the schema; the schema already documents the optional 'category' parameter. No enrichment is provided.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool lists server information including providers, tools, configuration, and signature databases. This is a specific verb-resource combination that distinguishes it from sibling tools which focus on specific actions like scanning or enumeration.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. The description does not mention exclusions, prerequisites, or context for using this meta tool over action-oriented siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

osintA

OSINT enrichment: Shodan host lookup, Censys search, reverse IP lookup, WHOIS information, Wayback Machine historical snapshots, and VirusTotal intelligence. Supports both IP and domain targets with auto-detection. 6 techniques in a single call.

ParametersJSON Schema
NameRequiredDescriptionDefault
typeNoTarget type (auto-detected if omitted)
targetYesIP address or domain for OSINT lookup

TDQS

A3.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It lists six techniques but does not explain whether the tool is read-only, has rate limits, requires authentication, or what side effects (if any) occur. The return format is not described.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence that efficiently communicates the tool's functionality without redundant information. It is well-structured for quick comprehension.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the absence of an output schema, the description should explain the return format or structure of results for the six techniques. It fails to do so, leaving the agent uncertain about what to expect from the call.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%. The description adds value by explaining the 'type' parameter is auto-detected if omitted, which is not in the schema. However, it does not elaborate on the 'target' parameter beyond schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose as OSINT enrichment with a specific list of techniques (Shodan, Censys, etc.) and targets (IP/domain). It distinguishes itself from sibling scanning tools by focusing on external intelligence gathering rather than active scanning.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description mentions auto-detection of target type but does not provide explicit guidance on when to use this tool versus alternatives like 'recon' or 'scan_ports'. No when-not-to-use or prerequisite information is given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

reconA

Full target reconnaissance. Runs HTTP headers, TLS certificate, DNS records, web technology detection, WAF/CDN, and infrastructure analysis in a single call. Use depth parameter to control scope: quick (~5 techniques, fast overview), standard (~20 techniques, balanced), deep (~50+ techniques, comprehensive).

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesTarget URL (e.g., https://example.com)
depthNoScan depth: quick (~5 techniques), standard (~20), deep (50+). Default: quick

TDQS

A4.2/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must fully convey behavioral traits. It outlines the types of analysis performed and depth options, but lacks details on rate limits, resource intensity, data persistence, or error handling. The description adds moderate value but could be more explicit about potential impacts.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three concise sentences: purpose, depth guidance, and depth details. No redundancy, front-loaded with key information. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (multiple techniques), the description covers the 'what' but omits the 'what you get back' since no output schema exists. It does not mention return structure or result format, which is a notable gap for an AI agent to understand the tool's output.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with good descriptions for both parameters. The description enriches the 'depth' parameter by detailing technique counts per enum value, providing clear decision-making context beyond the schema. For 'url', it adds an example format, reinforcing usage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool performs full target reconnaissance, listing specific techniques (HTTP headers, TLS, DNS, etc.) and distinguishes itself from sibling tools that focus on single aspects. The verb 'recon' is well-explained.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains when to use different depth levels (quick, standard, deep) with technique counts, providing clear guidance on scope. However, it does not explicitly contrast with sibling tools for when to use this combined tool versus individual scans, leaving a slight gap.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

scan_dnsB

Comprehensive DNS intelligence: full record enumeration, email infrastructure (MX/SPF/DKIM/DMARC), SaaS inventory from TXT records, nameserver fingerprinting, MTA-STS/DANE analysis, subdomain takeover detection, and reverse DNS. 7 techniques in a single call.

ParametersJSON Schema
NameRequiredDescriptionDefault
domainYesTarget domain

TDQS

B3.1/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must disclose behavior. It mentions '7 techniques in a single call' but omits critical details like rate limits, authentication, error handling, or whether it's read-only.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence listing 7 techniques, efficiently conveying scope without wasted words. It could be better structured but is acceptable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the absence of an output schema and annotations, the description should provide more context about return format or usage constraints. It only lists techniques but not what the output contains.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 100% coverage for the single parameter 'domain' described as 'Target domain'. The description adds no extra semantic meaning, so baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it's a comprehensive DNS intelligence tool, listing 7 specific techniques and differentiating from sibling tools like scan_http and scan_ports.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide any guidance on when to use this tool versus alternatives, nor does it mention when not to use it or any prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

scan_httpB

Comprehensive HTTP and web fingerprinting: header ordering, favicon hash, ETag analysis, error pages, cookies, HTTP methods, CORS, compression, caching, security headers, timing, redirect chains, web technology detection, analytics, source maps, API discovery, CMS/framework/ecommerce detection, and HTTP/2 analysis. ~29 techniques with smart skipping.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesTarget URL for HTTP fingerprinting

TDQS

B3.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so description must convey behavioral traits. It mentions 'smart skipping' but does not disclose if the tool is destructive, read-only, requires authentication, or has rate limits. Safety profile is unclear for a scanning tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description efficiently front-loads the purpose and lists techniques in a compact, comma-separated manner. No redundant text, though the list is long; still earns its space.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (29 techniques) and lack of output schema, the description omits details on result format, error handling, and usage constraints. Adequate but leaves gaps for an AI agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with a single parameter 'url' described as 'Target URL for HTTP fingerprinting'. The description adds no further parameter-level details, meeting the baseline for high coverage but providing no extra value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the tool performs comprehensive HTTP and web fingerprinting, listing numerous specific techniques. It distinguishes itself from sibling scan tools (like scan_ports, scan_dns) by focusing solely on web-layer reconnaissance.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use for in-depth HTTP analysis but does not explicitly contrast with alternatives or state when not to use it. 'Smart skipping' hints at efficiency, but no clear when-to/when-not-to guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

scan_pathsA

Path intelligence: sensitive file/directory probing (200+ paths across 11 categories), robots.txt/sitemap/security.txt parsing, version control and secret exposure detection, debug endpoint discovery with severity ratings, and API version probing. 5 techniques in a single call.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesBase URL for path probing
categoriesNopath_sensitive categories to probe (default: all 11 categories)

TDQS

A3.7/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It lists techniques but does not disclose behavioral traits like read-only nature, authorization requirements, rate limits, or whether results are returned synchronously. The mention of severity ratings hints at output but lacks depth.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, no wasted words. First sentence front-loads the key capabilities. Second sentence emphasizes efficiency. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema, so description should explain return values. It mentions 'severity ratings' but does not describe the output format or structure. Lacks completeness for an agent to fully understand what to expect.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so baseline 3. The description adds context about 200+ paths and 11 categories, but does not add parameter-specific meaning beyond what the schema already provides (e.g., enum values or validation rules).

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: path intelligence probing of sensitive files and directories across multiple categories, with specific techniques like robots.txt parsing, secret detection, and debug endpoint discovery. It distinguishes from siblings by emphasizing 200+ paths and 5 techniques in one call.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives like 'enumerate' or 'scan_http'. The description implies it's a comprehensive path probe but does not provide exclusions or when-not-to-use scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

scan_portsA

TCP port scanning with banner grabbing and automatic service detection. Probes specified ports, reads initial banners, detects protocols (SSH, MySQL, Redis, FTP, SMTP, HTTP, PostgreSQL, VNC, RDP), and runs targeted service fingerprinting on detected services.

ParametersJSON Schema
NameRequiredDescriptionDefault
hostYesTarget host
portsNoPorts to scan (default: common service ports)

TDQS

A3.6/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden and does well: it discloses that it probes ports, reads banners, detects protocols (listing examples), and runs targeted fingerprinting. It does not cover limitations (e.g., firewall impact) or what it does not do, but overall it provides a clear view of the tool's actions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences long, no wasted words. It front-loads the core function in the first sentence and elaborates in the second. Every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (two simple params, no output schema), the description covers the main functionality. It mentions detected protocols and fingerprinting. It lacks details on return format or error handling, but for a port scanner the description is largely sufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, with descriptions for 'host' (target host) and 'ports' (default common ports). The description adds that it probes specified ports and defaults to common service ports, aligning with the schema. No additional syntax or constraints are provided, so baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it performs TCP port scanning with banner grabbing and automatic service detection, listing specific protocols. It is a specific verb+resource combination. While the purpose is clear, it does not explicitly differentiate from sibling tools like scan_services, which also deals with service detection.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides context on what the tool does but offers no guidance on when to use it vs. alternatives, nor does it mention any prerequisites, exclusion criteria, or scenarios where it should not be used. The sibling tools include more specialized scans (scan_dns, scan_http) and analytic tools, but no comparison is made.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

scan_servicesA

Service-level fingerprinting for databases, caches, remote desktop, SSH, SMTP, and IoT. Supports auto-detection from port numbers or explicit service selection. Probes: MySQL, PostgreSQL, Redis, FTP, VNC/RDP, SSH (with full audit), SMTP (with TLS check), and IoT device detection.

ParametersJSON Schema
NameRequiredDescriptionDefault
hostYesTarget host
portsNoSpecific ports to probe
serviceNoService to probe (default: auto-detect from ports, or 'all')

TDQS

A4.5/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description discloses key behaviors: auto-detection, full audit for SSH, TLS check for SMTP. This is valuable beyond the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, zero waste. Front-loaded with purpose and service types, followed by detection modes and specific probes. Efficiently structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, the description adequately explains what the tool does and its capabilities. It covers purpose, detection modes, and service coverage, making it complete for an agent to decide when to use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with descriptions. The description adds context about auto-detection and lists all service enum values, enhancing understanding but not adding new parameter specifics.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it performs service-level fingerprinting for specific services (databases, caches, remote desktop, SSH, SMTP, IoT). It distinguishes from siblings like scan_ports by focusing on fingerprinting rather than just port scanning.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for fingerprinting services, supports auto-detection or explicit selection. It doesn't explicitly state when not to use or name alternatives, but the context from siblings is sufficient.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

scan_tlsB

Complete TLS/SSL analysis: handshake probe, JARM fingerprint, certificate deep inspection, JA4X generation fingerprint, cipher suite enumeration, SNI probing, certificate cross-referencing, and CT subdomain discovery. 8 techniques in a single call.

ParametersJSON Schema
NameRequiredDescriptionDefault
hostYesTarget hostname
portNoTLS port (default: 443)

TDQS

B3.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. It lists techniques but does not mention side effects, resource usage, or any constraints. For a tool performing scans, information on rate limits or read-only nature is missing.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Description is a single, efficient sentence that front-loads the core purpose and lists techniques concisely. No unnecessary words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a complex tool with 8 techniques and no output schema, the description adequately summarizes capabilities but lacks detail on output format or return value structure, which may be needed for an agent to fully understand the result.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. Description does not add any parameter-level meaning beyond the schema. Parameters are simple and well-documented in schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states 'Complete TLS/SSL analysis' and enumerates 8 specific techniques, providing a specific verb+resource pair. It distinguishes from sibling scanning tools by focusing solely on TLS.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Description implies comprehensiveness with '8 techniques in a single call' but does not explicitly state when to use this tool over alternatives like scan_ports or scan_http. No when-not or alternative tool advice.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

scan_wafB

WAF and CDN analysis: WAF identification via attack payload probing, CDN provider detection from headers/DNS, deep WAF technology fingerprinting from block pages, and origin IP discovery behind CDN. 4 techniques with conditional origin discovery.

ParametersJSON Schema
NameRequiredDescriptionDefault
urlYesTarget URL for WAF/CDN analysis

TDQS

B3.3/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry full burden. It mentions 'attack payload probing' which could be destructive, but fails to warn about potential consequences like triggering alarms or legal issues. Conditional origin discovery is noted but not explained.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that efficiently lists all techniques, though it is somewhat dense. It is front-loaded with the primary function.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema is present, and the description does not describe what the tool returns. Given the complexity (four techniques), this is a significant gap. Also lacks safety context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Only one parameter (url) with 100% schema description coverage. The description adds no extra meaning beyond 'Target URL for WAF/CDN analysis' already in the schema. Baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description explicitly states 'WAF and CDN analysis' and lists four specific techniques (WAF identification, CDN detection, WAF fingerprinting, origin IP discovery). It clearly distinguishes from sibling scan tools like scan_ports and scan_http which target different aspects.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for assessing WAF/CDN configuration but does not explicitly state when to use versus alternatives such as other scan tools. No guidance on prerequisites or when not to use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 13 tool updatesv0.1.0
    • First observedanalyze
    • First observedcorrelate
    • First observedenumerate
    • First observedmeta
    • First observedosint
    • First observedrecon
    • First observedscan_dns
    • First observedscan_http
    • First observedscan_paths
    • First observedscan_ports
    • First observedscan_services
    • First observedscan_tls
    • First observedscan_waf

TDQS

A3.8/5.0

Scored across 13 tools

Disambiguation5/5

Each tool has a clearly distinct purpose: passive analysis, active scanning (DNS, HTTP, paths, ports, services, TLS, WAF), OSINT, enumeration, correlation, and meta. Descriptions provide detailed technique lists, eliminating ambiguity.

Naming Consistency5/5

All tool names use lowercase with underscores, following a consistent verb_noun pattern (e.g., scan_dns, analyze, osint). No mixing of styles, making the naming predictable.

Tool Count5/5

13 tools cover the fingerprinting domain comprehensively without excess. Each tool represents a core capability, and the count is well-scoped for the server's purpose.

Completeness5/5

The toolset covers passive analysis, multiple scanning layers (DNS, HTTP, ports, services, TLS, WAF, paths), OSINT, enumeration, correlation, and meta-info. No obvious gaps for the fingerprinting domain.

Maintenance

ActivityStale
ResponsivenessNo issues

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    D
    maintenance
    A comprehensive MCP server that exposes multiple OSINT tools to AI assistants like Claude, enabling sophisticated reconnaissance and information gathering tasks using industry-standard OSINT tools.
    237
    MIT
  • F
    license
    Not graded
    quality
    C
    maintenance
    A production-style MCP server providing AI models with cybersecurity tools including port scanning, WHOIS, DNS, threat intelligence, CVE lookup, and more.
    -

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/badchars/fingerprint-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server