Skip to main content
Glama

VulneraMCP

An AI-Powered Bug Bounty MCP Server — recon, vulnerability testing, API/auth/cloud scanning, graph analysis, and reporting for security researchers and bug bounty hunters.

License: MIT TypeScript Node.js Demo Glama

VulneraMCP is a Model Context Protocol (MCP) server for bug bounty hunting and security testing. It integrates OWASP ZAP, optional Caido/Burp Suite, and CLI tools (subfinder, httpx, gau, ffuf) for reconnaissance, JavaScript analysis, XSS/SQLi/IDOR/CSRF testing, API and auth misconfiguration checks, cloud bucket and secret scanning, orchestrated scan flows, knowledge-graph analysis, wordlist generation, and Markdown reporting — with PostgreSQL storage for findings and test results.

🎬 Demo

Watch the VulneraMCP demonstration on YouTube: https://youtu.be/wlUvBVNyh74

Related MCP server: Bug Bounty MCP Server

🌟 Features

🔍 Reconnaissance Tools

  • Subdomain Discovery: Subfinder, Amass integration

  • Live Host Detection: HTTPx for checking active endpoints

  • DNS Resolution: DNS record enumeration (A, AAAA, CNAME, MX, TXT)

  • URL Discovery: Gau (Get All URLs) from archives and crawlers

  • Fuzzing: ffuf for directory, file, and parameter discovery

  • Full Recon Workflow: Automated multi-tool reconnaissance

🔐 Security Testing

  • XSS Testing: Automated cross-site scripting detection

  • SQL Injection: SQLi vulnerability testing with sqlmap fallback

  • IDOR Detection: Insecure Direct Object Reference testing

  • CSP Analysis: Content Security Policy misconfiguration detection

  • Auth Bypass: Authentication bypass attempt testing

  • CSRF Testing: Cross-Site Request Forgery detection with advanced techniques

🌐 API Testing

  • GraphQL: Introspection and misconfiguration checks

  • Rate Limiting: Endpoint rate limit testing

  • BOLA / IDOR: Broken object level authorization tests

  • Mass Assignment: Unsafe field assignment detection

  • Swagger/OpenAPI: API documentation enumeration

🔑 Authentication Testing

  • JWT: None algorithm and algorithm confusion attacks

  • OAuth: Misconfiguration detection

  • Session: Fixation and cookie flag analysis

  • Password Reset: Host header poisoning tests

  • MFA: Bypass signal detection and testing

☁️ Cloud Security

  • Storage: S3/Azure/GCP bucket enumeration and permission probes

  • Secrets: Exposed key scanning in JS, HTML, and env files

  • Terraform: State file leak detection

🎯 Scanner Orchestration

  • Target Normalization: Standardize targets for multi-tool flows

  • Run Flow: Orchestrated scanning across API, auth, and cloud tools

  • Finding Correlation: Link and correlate results across tests

📈 Graph Analysis

  • Knowledge Graph: Store targets, findings, and relationships in PostgreSQL

  • Pattern Detection: Extract patterns and find similar findings

  • Attack Graphs: Generate, rank, and export attack paths (JSON, GraphML)

📝 Reporting & Wordlists

  • Report Generation: Markdown reports from findings

  • Wordlist Generation: Directories, files, parameters, and combined lists

📜 JavaScript Analysis

  • JS Download: Download and analyze JavaScript files

  • Code Beautification: Format and beautify minified JS

  • Endpoint Extraction: Find API endpoints and URLs in JS

  • Secret Detection: Heuristic API key and token extraction

  • Full Analysis: Combined download, beautify, and analyze workflow

🕷️ Integration

  • Spider Scans: Automated web crawling

  • Active Scanning: Vulnerability scanning

  • Proxy Integration: Process requests through ZAP proxy

  • Alert Management: Retrieve and analyze security alerts

  • Context Management: Define scanning contexts

💾 Database Integration

  • PostgreSQL: Store findings, test results, and scores

  • Redis: Working memory and caching (optional)

  • Finding Management: Save and retrieve bug findings

  • Test Result Storage: Track all security tests with statistics

🖼️ Rendering Tools

  • Screenshots: Capture webpage screenshots with Puppeteer

  • DOM Extraction: Extract and analyze page structure

  • Form Extraction: Find and analyze web forms

  • JavaScript Execution: Execute JS in page context

🤖 AI Training & Pattern Matching

  • Training Data Import: Import from HTB, PortSwigger labs

  • Pattern Matching: Learn from successful exploits

  • Writeup Analysis: Extract patterns from bug bounty writeups

  • CSRF Patterns: Pre-loaded CSRF exploitation patterns

📊 Web Dashboard

  • Real-time Statistics: View test results and findings

  • Finding Management: Browse and analyze discovered vulnerabilities

  • Visual Analytics: Track testing progress and success rates

🚀 Quick Start

Prerequisites

  • Node.js 20+ and npm

  • PostgreSQL 18+ (or Docker)

  • Redis (optional, for caching)

  • ZAP (optional, for active scanning)

  • Caido (optional, for traffic analysis)

Installation

# Clone the repository
git clone https://github.com/telmon95/VulneraMCP.git
cd VulneraMCP

# Install dependencies
npm install

# Build the project
npm run build

Configuration

  1. Copy environment template:

    cp mcp.json.example mcp.json
  2. Configure your environment variables:

    • Set up PostgreSQL connection details

    • Configure Caido API token (if using)

    • Set ZAP API URL (default: http://localhost:8081)

  3. Initialize the database:

    node init-db.js

Running the Server

# Start the MCP server
npm start

# Start the dashboard (in another terminal)
npm run dashboard

# Access dashboard at http://localhost:3000

Docker Setup

# Start all services with Docker Compose
docker-compose up -d

# Or use the startup script
./start-services.sh

📖 Usage

Via MCP Client (Cursor, Claude Desktop, etc.)

The server provides MCP tools that can be called through any MCP-compatible client:

Reconnaissance:

recon.subfinder domain: example.com
recon.httpx input: example.com,subdomain.example.com
recon.full domain: example.com

Security Testing:

security.test_xss url: https://example.com/search?q=<script>
security.test_sqli url: https://example.com/user?id=1
security.test_csrf url: https://example.com/profile/update

JavaScript Analysis:

js.analyze url: https://example.com/static/app.js
js.extract_secrets source: <javascript_code>

ZAP Integration:

zap.start_spider url: https://example.com
zap.start_active_scan url: https://example.com
zap.get_alerts baseURL: https://example.com

Caido Integration:

caido.query httpql: "req.host.cont:\"example.com\" AND req.path.cont:\"api\""
caido.agent_discover_endpoints host: example.com

Rate Limiting & Best Practices

When testing bug bounty programs, always respect rate limits:

// Example: 2 requests/second limit
const rateLimiter = require('./hunting/rate-limiter');
const limiter = rateLimiter(2); // 2 req/sec

await limiter();
// Make your request

🏗️ Project Structure

VulneraMCP/
├── src/
│   ├── integrations/    # External service integrations
│   │   ├── zap.ts       # OWASP ZAP integration
│   │   ├── caido.ts     # Caido integration
│   │   ├── postgres.ts  # PostgreSQL database
│   │   └── redis.ts     # Redis caching
│   ├── tools/           # MCP tools (recon, security, etc.)
│   ├── mcp/             # MCP server implementation
│   └── index.ts         # Main entry point
├── public/              # Dashboard frontend
├── hunting/             # Bug bounty hunting scripts
├── dist/                # Compiled TypeScript output
└── dashboard-server.js  # Dashboard API server

🔧 Configuration

MCP Server Configuration (mcp.json)

{
  "name": "vulneramcp",
  "command": "node",
  "args": ["dist/index.js"],
  "env": {
    "POSTGRES_HOST": "localhost",
    "POSTGRES_PORT": "5433",
    "POSTGRES_USER": "postgres",
    "POSTGRES_DB": "bugbounty"
  }
}

Environment Variables

# PostgreSQL
POSTGRES_HOST=localhost
POSTGRES_PORT=5433
POSTGRES_USER=postgres
POSTGRES_PASSWORD=your_password
POSTGRES_DB=bugbounty

# ZAP
ZAP_API_URL=http://localhost:8081

# Caido
CAIDO_API_TOKEN=your_token

# Redis (optional)
REDIS_HOST=localhost
REDIS_PORT=6379

📊 Dashboard

The web dashboard provides:

  • Statistics: Test results, success rates, vulnerability distribution

  • Findings: Detailed view of discovered vulnerabilities

  • Search & Filter: Find specific findings by target, type, severity

Access at: http://localhost:3000

💖 Sponsor

If VulneraMCP helps your bug bounty or security research workflow, consider sponsoring development on GitHub Sponsors.

Your support helps fund new features, documentation, security testing, and long-term maintenance of this open source project.

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

  1. Fork the repository

  2. Create your feature branch (git checkout -b feature/AmazingFeature)

  3. Commit your changes (git commit -m 'Add some AmazingFeature')

  4. Push to the branch (git push origin feature/AmazingFeature)

  5. Open a Pull Request

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

⚠️ Disclaimer

This tool is for authorized security testing only. Always:

  • Get proper authorization before testing

  • Respect rate limits and terms of service

  • Follow responsible disclosure practices

  • Never use on systems you don't own or have explicit permission to test

🙏 Acknowledgments

  • ZAP for vulnerability scanning

  • The bug bounty community for inspiration and feedback

📚 Documentation

🐛 Issues

Found a bug? Have a feature request? Please open an issue on GitHub.

📧 Contact

Available Tools

47 tools
db.get_findingsC

Retrieve bug findings from the database

Inputs: target, limit.

db.get_statisticsC

Get statistics about test results

Inputs: no named parameters.

db.get_test_resultsB

Retrieve test results with success/failure and scores

Inputs: target, testType, success, limit.

db.initA

Initialize database tables (run once on first setup)

Inputs: no named parameters.

db.save_findingC

Save a bug finding to the database

Inputs: target (required), type (required), severity (required), description (required), +3 more.

js.analyzeA

Download, beautify, and analyze a JavaScript file - extract endpoints and secrets

Inputs: url (required).

js.beautifyC

Beautify and format JavaScript source code

Inputs: source (required), indentSize.

js.downloadC

Download JavaScript file from URL

Inputs: url (required).

js.extract_secretsC

Heuristically extract potential API keys, tokens, and secrets from JS

Inputs: source (required).

js.find_endpointsC

Extract API endpoints, URLs, and paths from JavaScript code

Inputs: source (required).

recon.amassC

Run amass for passive/active subdomain enumeration

Inputs: domain (required), passive.

recon.dnsB

Resolve DNS records for a domain or subdomain

Inputs: domain (required), recordType.

recon.fullC

Run full reconnaissance workflow: subfinder -> httpx -> amass

Inputs: domain (required).

recon.httpxC

Run httpx to check which hosts are live and get status codes

Inputs: input (required), statusCode, title.

recon.subfinderC

Run subfinder to discover subdomains for a domain

Inputs: domain (required), silent.

render.execute_jsC

Execute JavaScript in the context of a webpage

Inputs: url (required), script (required).

render.extract_domC

Extract and return the DOM structure of a webpage

Inputs: url (required), waitTime.

render.extract_formsB

Extract all forms from a webpage

Inputs: url (required).

render.screenshotC

Take a screenshot of a webpage

Inputs: url (required), fullPage, waitTime.

security.test_auth_bypassC

Test for authentication bypass vulnerabilities

Inputs: url (required), method.

security.test_cspC

Test Content Security Policy configuration

Inputs: url (required).

security.test_csrfC

Test for CSRF vulnerabilities using advanced techniques

Inputs: url (required), method, params, testTechniques.

security.test_idorC

Test for IDOR (Insecure Direct Object Reference) vulnerabilities

Inputs: url (required), idParam, testIds.

security.test_sqliC

Test for SQL injection vulnerabilities

Inputs: url (required), param.

security.test_xssC

Test for XSS vulnerabilities (non-destructive payloads)

Inputs: url (required), params, method.

training.extract_from_writeupC

Extract training patterns from bug bounty writeup text

Inputs: writeupText (required), vulnerabilityType (required), source.

training.getC

Retrieve training data for learning patterns

Inputs: vulnerabilityType, source, limit.

training.get_csrf_patternsC

Get all CSRF exploitation patterns from training data

Inputs: technique.

training.importC

Import training data from HTB or PortSwigger labs

Inputs: source (required), vulnerabilityType (required), targetPattern (required), payloadPattern (required), +5 more.

training.import_allC

Import all pre-loaded training data from Intigriti, PortSwigger, and other sources

Inputs: sources.

training.import_htbB

Import training data from HackTheBox challenge

Inputs: challengeName (required), vulnerabilityType (required), exploit (required), challengeUrl.

training.import_portswiggerC

Import training data from PortSwigger Academy lab solution

Inputs: labName (required), vulnerabilityType (required), solution (required), labUrl.

training.matchC

Match current test against learned patterns

Inputs: vulnerabilityType (required), target (required), payload (required), response (required).

training.statsB

Get statistics about test results and training data

Inputs: no named parameters.

zap.create_contextC

Create a scanning context in ZAP

Inputs: contextName (required).

zap.get_active_scan_statusC

Get the status of an active scan

Inputs: scanId (required).

zap.get_alertsB

Get all security alerts from ZAP

Inputs: baseURL, start, count, riskId.

zap.get_alerts_summaryC

Get summary of alerts by risk level

Inputs: baseURL.

zap.get_sitesB

Get list of discovered sites from ZAP

Inputs: no named parameters.

zap.get_spider_statusC

Get the status of a spider scan

Inputs: scanId (required).

zap.get_urlsB

Get list of discovered URLs from ZAP

Inputs: baseURL.

zap.health_checkB

Check if ZAP is running and accessible

Inputs: no named parameters.

zap.include_in_contextC

Include a URL pattern in a context

Inputs: contextName (required), regex (required).

zap.proxy_processC

Process a request through the MCP proxy layer (enhances with AI intelligence)

Inputs: method (required), url (required), headers, body.

zap.send_requestC

Send a custom HTTP request through ZAP proxy

Inputs: url (required), method, headers, body.

zap.start_active_scanC

Start an active vulnerability scan on a target URL

Inputs: url (required), recurse, inScopeOnly, scanPolicyName, +2 more.

zap.start_spiderB

Start a spider (crawler) scan on a target URL

Inputs: url (required), maxChildren, recurse, contextName.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    B3.2/5.0

    Scored across 47 tools

    Disambiguation4/5

    The tools are well-organized into clear functional categories (db, js, recon, render, security, training, zap), which helps disambiguation significantly. However, within categories like 'training' there are multiple import tools (import, import_all, import_htb, import_portswigger) that could cause confusion about which to use for specific scenarios. The overall structure prevents major misselection issues.

    Naming Consistency5/5

    Excellent naming consistency throughout. All tools follow a consistent 'category.action' pattern (e.g., 'db.get_findings', 'js.analyze', 'security.test_xss'). The verb_noun structure is maintained within each category, and there's no mixing of naming conventions. This predictability makes the tool set easy to navigate.

    Tool Count2/5

    With 47 tools, this server feels overloaded for a single MCP server. While the domain (vulnerability assessment) is broad, the tool count creates cognitive overhead and suggests the server might be trying to do too much. A more focused approach with 15-25 tools would likely be more appropriate for agent usability.

    Completeness5/5

    The tool surface provides comprehensive coverage of the vulnerability assessment domain. It includes database operations, JavaScript analysis, reconnaissance, rendering, security testing, training data management, and ZAP integration. The tools support complete workflows from reconnaissance through testing to result analysis, with no obvious gaps in the core functionality.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      AI-powered cybersecurity automation platform with 150+ security tools and 12+ autonomous AI agents for penetration testing, vulnerability assessment, and bug bounty hunting. Enables comprehensive security testing through intelligent tool selection and automated workflows.
      3
      -
    • A
      license
      C
      quality
      D
      maintenance
      Enables AI agents to generate and manage specialized bug bounty hunting workflows including reconnaissance, vulnerability testing, OSINT gathering, and file upload testing. Provides REST API endpoints for comprehensive security assessments with intelligence-driven vulnerability prioritization.
      40
      2
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      Enables comprehensive security testing and penetration testing through natural language conversations with 92+ tools for reconnaissance, vulnerability assessment, web application testing, OSINT, and reporting. Designed for authorized bug bounty hunting and security assessments.
      53
      44
      MIT