# Kali Burp Mcp Bridge

> kali-burp-mcp-bridge is a Model Context Protocol (MCP) server that gives any AI assistant (Claude, ChatGPT, Cursor, and more) direct access to your Kali Linux security toolchain and Burp Suite REST API — turning your AI into a fully-equipped penetration tester.

- **Type:** MCP server
- **Install:** `agentstack add mcp-hyperps-kali-burp-mcp-bridge`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [HyperPS](https://agentstack.voostack.com/s/hyperps)
- **Installs:** 0
- **Category:** [Integrations](https://agentstack.voostack.com/c/integrations)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [HyperPS](https://github.com/HyperPS)
- **Source:** https://github.com/HyperPS/kali-burp-mcp-bridge

## Install

```sh
agentstack add mcp-hyperps-kali-burp-mcp-bridge
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# 🛡️ kali-burp-mcp-bridge

### *The Ultimate AI-Powered Penetration Testing MCP Server*

[](https://python.org)
[](https://modelcontextprotocol.io)
[](https://portswigger.net)
[](https://kali.org)
[](LICENSE)
[](https://github.com/hyperps/kali-burp-mcp-bridge/stargazers)

**Connect Claude, ChatGPT, Cursor, and any MCP-compatible AI to your full Kali Linux + Burp Suite security toolkit.**

Run `nmap`, `sqlmap`, `metasploit`, `hydra`, `nuclei` and 60+ more tools — all from a single chat prompt.

[🚀 Quick Start](#-quick-start) · [🔧 All Tools](#-available-tools) · [🤖 AI Setup](#-connecting-your-ai) · [📖 Examples](#-usage-examples) · [🙏 Credits](#-credits)

---

> ⚠️ **Legal Disclaimer:** This tool is intended for **authorized penetration testing and security research only**. Always obtain explicit written permission before testing any system you do not own. Misuse of this tool is illegal and unethical. The authors accept no liability for unauthorized use.
#### This project is not intended to be exposed publicly without authentication. The kali-burp-mcp-bridge server is designed to run locally or behind a trusted boundary (e.g., internal lab environment, VPN, or secured reverse proxy) and is expected to be protected by an authentication token or equivalent access control mechanism at deployment time.
#### The functions highlighted (Metasploit integration, CLI wrappers, file-based tooling, etc.) are intentionally designed for controlled offensive security environments where the operator is already trusted and authorized. This bridge acts as a thin execution layer between MCP and local security tooling — not as a hardened multi-tenant API service.
---

## 📌 What Is This?

`kali-burp-mcp-bridge` (entry point: **`server.py`**) is a **Model Context Protocol (MCP) server** that gives any AI assistant — Claude, ChatGPT, Cursor, and more — direct, real-time access to your Kali Linux security toolchain and Burp Suite REST API.

It bridges three powerful layers into one conversational interface:

```
You ──► AI Chat ──► server.py (MCP Server) ──► 🔴 Burp Suite REST API
                                           ├──► 🟡 Kali Linux CLI Tools
                                           └──► 🟢 Pure Python Security Modules
```

Instead of switching between terminals and GUI tools, you simply describe what you want:

> *"Scan 10.10.10.5 for open ports, identify services, and check for known CVEs"*

And your AI assistant automatically calls `nmap_scan`, `whatweb_scan`, and `search_cve_by_keyword` for you.

---

## 🏗️ Architecture

```
╔══════════════════════════════════════════════════════════════╗
║           kali-burp-mcp-bridge  v3.0  (server.py)           ║
╠══════════════════════════════════════════════════════════════╣
║  🔴 Layer 1 — Burp Suite REST API  (port 9876)              ║
║     Proxy history · Active/passive scanner · Repeater        ║
║     Intruder · Collaborator OOB · Encoding · Config          ║
╠══════════════════════════════════════════════════════════════╣
║  🟡 Layer 2 — Kali Linux CLI Tools                          ║
║     nmap · masscan · nikto · gobuster · ffuf · dirb          ║
║     sqlmap · hydra · john · hashcat · metasploit             ║
║     whatweb · wpscan · nuclei · enum4linux · smbclient       ║
║     subfinder · amass · fierce · dnsx · sslscan              ║
║     curl · wget · netcat · openssl · whois · dig             ║
╠══════════════════════════════════════════════════════════════╣
║  🟢 Layer 3 — Pure Python Security Modules                  ║
║     JWT decode/forge/brute · CORS · HTTP smuggling           ║
║     SSRF probe · Cache poisoning · OAuth analysis            ║
║     GraphQL introspect · Session entropy · Param mining      ║
║     CVE lookup · GitHub secret scan · Exploit templates      ║
╚══════════════════════════════════════════════════════════════╝

  MCP Transport:  stdio (default)  |  SSE port 8082 (--transport sse)
  Burp REST API:  http://127.0.0.1:9876  (via BurpAI extension)
```

---

## 🚀 Quick Start

### Step 1 — Clone the Repo

```bash
git clone https://github.com/yourusername/kali-burp-mcp-bridge.git
cd kali-burp-mcp-bridge
```

### Step 2 — Install Python Dependencies

The script uses inline PEP 723 dependency metadata, so you can use `uv` for zero-config setup:

```bash
# Option A — using uv (recommended, auto-installs all deps)
pip install uv
uv run server.py

# Option B — using pip manually
pip install "requests>=2,=1.2.0,=3,=1.6"
python3 server.py
```

### Step 3 — Install Kali Security Tools

```bash
sudo apt-get update && sudo apt-get install -y \
  nmap masscan nikto gobuster dirb ffuf sqlmap \
  hydra john hashcat whatweb wpscan \
  enum4linux smbclient netcat-openbsd \
  curl wget whois dnsutils sslscan \
  amass subfinder fierce \
  metasploit-framework

# Wordlists
sudo apt-get install -y wordlists seclists
sudo gunzip /usr/share/wordlists/rockyou.txt.gz 2>/dev/null || true

# Go-based tools (nuclei, dnsx, ffuf, gobuster latest)
go install github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest
go install github.com/projectdiscovery/dnsx/cmd/dnsx@latest
go install github.com/ffuf/ffuf/v2@latest
```

> You can also install any missing tool at any time by asking your AI: *"Install nuclei"* — the `install_tool` function handles apt, pip, and go automatically.

### Step 4 — Connect Your AI

See the full connection guide below.

---

## 🤖 Connecting Your AI

### 🟣 Claude (Anthropic) — Claude Desktop App

Claude supports MCP natively via the Desktop app. This is the easiest and most powerful integration.

**Find your config file:**

| OS | Path |
|----|------|
| macOS | `~/Library/Application Support/Claude/claude_desktop_config.json` |
| Windows | `%APPDATA%\Claude\claude_desktop_config.json` |
| Linux | `~/.config/Claude/claude_desktop_config.json` |

**Add this to your config:**

```json
{
  "mcpServers": {
    "kali-burp": {
      "command": "python3",
      "args": ["/full/path/to/kali-burp-mcp-bridge/server.py"],
      "env": {
        "BURP_URL": "http://127.0.0.1:9876",
        "BURP_API_KEY": "",
        "TOOL_TIMEOUT": "120"
      }
    }
  }
}
```

Restart Claude Desktop. You will see the 🔧 tools icon in the chat interface confirming the MCP server is active.

**For a remote Kali machine, use SSE mode:**

```bash
# On your Kali machine
python3 server.py --transport sse --mcp-host 0.0.0.0 --mcp-port 8082
```

```json
{
  "mcpServers": {
    "kali-burp-remote": {
      "url": "http://YOUR_KALI_IP:8082/sse"
    }
  }
}
```

---

### 🟢 Claude.ai (Web Interface)

Claude.ai supports MCP via remote SSE connections.

```bash
# Start SSE server on your machine
python3 server.py --transport sse --mcp-host 0.0.0.0 --mcp-port 8082
```

In Claude.ai settings, navigate to **Integrations → Add MCP Server** and enter:

```
http://YOUR_IP:8082/sse
```

> For claude.ai to reach your server over the internet, expose the port or use a tunnel:
> ```bash
> ngrok http 8082
> # Then use the ngrok HTTPS URL in claude.ai
> ```

---

### 🟡 ChatGPT / OpenAI — Agents SDK

ChatGPT connects via the SSE transport using the OpenAI Agents SDK.

```bash
# Start SSE server first
python3 server.py --transport sse --mcp-port 8082
```

```python
# pip install openai-agents
from agents import Agent, MCPServerSse
import asyncio

async def main():
    async with MCPServerSse(
        name="kali-burp",
        params={"url": "http://127.0.0.1:8082/sse"},
    ) as mcp_server:
        agent = Agent(
            name="PenTest Agent",
            instructions="You are an expert penetration tester. Use the available tools to help test targets.",
            mcp_servers=[mcp_server],
        )
        result = await agent.run("Scan 10.10.10.5 for open ports and identify services")
        print(result.final_output)

asyncio.run(main())
```

---

### 🔵 Cursor IDE

Add to `~/.cursor/mcp.json`:

```json
{
  "mcpServers": {
    "kali-burp": {
      "command": "python3",
      "args": ["/full/path/to/server.py"],
      "env": {
        "BURP_URL": "http://127.0.0.1:9876",
        "TOOL_TIMEOUT": "120"
      }
    }
  }
}
```

Restart Cursor. The tools appear automatically in the AI chat panel.

---

### 🟠 Windsurf (Codeium)

Add to your Windsurf MCP configuration file:

```json
{
  "mcp": {
    "servers": {
      "kali-burp": {
        "command": "python3",
        "args": ["/full/path/to/server.py"],
        "env": {
          "BURP_URL": "http://127.0.0.1:9876"
        }
      }
    }
  }
}
```

---

### ⚪ Any MCP-Compatible Client (Generic SSE)

```bash
# Start in SSE mode
python3 server.py --transport sse --mcp-host 0.0.0.0 --mcp-port 8082

# Connect any MCP client to:
# http://YOUR_HOST:8082/sse
```

This works with LangChain MCP adapters, CrewAI, AutoGen, LlamaIndex, and any framework that supports the MCP SSE transport protocol.

---

## 🔧 Available Tools

### 🌐 Network Scanning

| Tool | Description |
|------|-------------|
| `nmap_scan` | Port and service scan with custom flags (e.g. `-sV -T4 --open`) |
| `nmap_vuln_scan` | Run all Nmap vuln NSE scripts against a target |
| `nmap_os_detect` | OS fingerprinting with `-O -sV -A` |
| `nmap_full_port_scan` | Scan all 65535 ports (slow but thorough) |
| `nmap_udp_scan` | UDP scan for top N ports (requires root) |
| `nmap_script` | Run any specific NSE script (e.g. `smb-vuln-ms17-010`) |
| `masscan_fast` | Ultra-fast packet-level port sweep with configurable rate |

### 🕸️ Web Scanning and Fuzzing

| Tool | Description |
|------|-------------|
| `nikto_scan` | Web server vulnerability scan by host and port |
| `nikto_scan_url` | Nikto scan using a full URL (auto-detects HTTPS) |
| `gobuster_dir` | Directory and file brute-force with extension support |
| `gobuster_dns` | Subdomain brute-force via DNS resolution |
| `gobuster_vhost` | Virtual host enumeration |
| `dirb_scan` | Classic directory scan (fallback when gobuster unavailable) |
| `ffuf_dir` | Fast web directory fuzzing using FUZZ placeholder |
| `ffuf_param` | Parameter fuzzing with custom HTTP method and POST data |
| `wpscan` | WordPress scanner for users, plugins, themes, and timthumbs |
| `nuclei_scan` | Template-based vulnerability scanning (community templates) |
| `nuclei_scan_list` | Nuclei against a file containing multiple target URLs |
| `whatweb_scan` | Web technology fingerprinting with configurable aggression |

### 💉 SQL Injection

| Tool | Description |
|------|-------------|
| `sqlmap_scan` | Full SQL injection test on a URL |
| `sqlmap_dbs` | Enumerate available databases |
| `sqlmap_tables` | Enumerate tables within a specific database |
| `sqlmap_dump` | Dump data from a database or table |
| `sqlmap_os_shell` | Attempt OS command execution via SQLi |
| `sqlmap_request_file` | Test from a saved Burp Suite request file |

### 🔐 Brute Force and Hash Cracking

| Tool | Description |
|------|-------------|
| `hydra_ssh` | SSH credential brute-force |
| `hydra_ftp` | FTP credential brute-force |
| `hydra_smb` | SMB credential brute-force |
| `hydra_http_post` | HTTP POST login form attack with fail string |
| `hydra_service` | Generic service attack (rdp, smtp, mysql, mssql, telnet, etc.) |
| `john_crack` | John the Ripper with wordlist and optional rules |
| `john_show` | Display previously cracked passwords |
| `hashcat_crack` | GPU-accelerated cracking (MD5, NTLM, SHA1, bcrypt, etc.) |

### 💣 Exploitation — Metasploit

| Tool | Description |
|------|-------------|
| `msf_exploit` | Run an exploit with RHOSTS, LHOST, LPORT, PAYLOAD options |
| `msf_generate_payload` | msfvenom payload generation (exe, elf, apk, ps1, dll, raw) |
| `msf_search` | Search the Metasploit module database by keyword |
| `msf_module_info` | Get detailed information on a specific module |
| `msf_run_resource` | Execute a full multi-line Metasploit .rc resource script |

### 🔍 Reconnaissance and OSINT

| Tool | Description |
|------|-------------|
| `subfinder_enum` | Passive subdomain enumeration via OSINT sources |
| `amass_enum` | Active and passive subdomain mapping |
| `enumerate_subdomains` | crt.sh certificate transparency logs plus DNS resolution |
| `fierce_dns` | DNS reconnaissance and zone transfer attempts |
| `dnsx_resolve` | Fast DNS resolution with A, CNAME, MX, NS records |
| `whois_lookup` | WHOIS data for a domain or IP address |
| `dig_query` | DNS query for any record type via any nameserver |
| `enum4linux` | SMB and LDAP enumeration for shares, users, and groups |
| `smbclient_list_shares` | List SMB shares on a target |
| `smbclient_connect` | Connect to an SMB share and execute commands |
| `github_repo_secret_scan` | Scan GitHub repo commits for exposed API keys and secrets |

### 🔑 JWT and Authentication Testing

| Tool | Description |
|------|-------------|
| `jwt_decode` | Decode JWT header and payload, detect algorithm and expiry issues |
| `jwt_forge_none_alg` | Generate `alg:none` bypass tokens (4 casing variants) |
| `jwt_brute_secret` | Brute-force HS256 secret against common passwords or a wordlist |
| `analyze_oauth_flow` | Detect OAuth misconfigurations: implicit flow, missing state, missing PKCE |

### 🕵️ Advanced Web Vulnerability Testing

| Tool | Description |
|------|-------------|
| `test_cors_misconfiguration` | Test CORS policy for origin reflection and credential leakage |
| `detect_request_smuggling` | Raw socket HTTP smuggling detection (CL.TE and TE.CL techniques) |
| `test_host_header_injection` | Host header injection via X-Forwarded-Host and OOB Collaborator |
| `detect_cache_poisoning` | Unkeyed header cache poisoning detection |
| `probe_ssrf` | SSRF via AWS/GCP/Azure metadata endpoints and Burp Collaborator OOB |
| `scan_open_redirects` | Open redirect scanning across common URL parameters |
| `mine_hidden_parameters` | Discover hidden parameters by comparing response length and status |
| `graphql_introspect` | GraphQL schema extraction via introspection query |
| `discover_api_endpoints_from_js` | Extract API paths, secrets, and external URLs from JavaScript files |
| `analyze_session_entropy` | Token entropy analysis and sequential pattern detection |

### 🎯 Payloads and Exploit Templates

| Tool | Description |
|------|-------------|
| `get_payloads` | Return payloads for: sqli, xss, ssti, ssrf, xxe, lfi, cmd_injection, open_redirect |
| `get_all_payload_types` | List all available payload categories |
| `generate_exploit_template` | Generate a ready-to-run Python exploit script for a vulnerability type |
| `auto_exploit_from_scan` | Pull Burp scanner findings and auto-generate exploit scripts per issue |
| `build_intruder_attack` | Load Burp Intruder with generated payloads for a given attack type |

### 🔬 CVE Intelligence

| Tool | Description |
|------|-------------|
| `lookup_cve` | Full CVE details from NVD including CVSS v3 score and references |
| `search_cve_by_keyword` | Keyword-based CVE search against the NVD database |
| `tech_to_cves` | Map a detected technology and version to known CVEs |
| `github_advisory_search` | GitHub Security Advisories by ecosystem, severity, or keyword |

### 🔒 SSL and TLS Testing

| Tool | Description |
|------|-------------|
| `sslscan` | Test SSL/TLS ciphers, protocols, and known vulnerabilities |
| `testssl` | Comprehensive TLS testing with testssl.sh |
| `openssl_check_cert` | Display full certificate chain and certificate details |

### 🌊 Burp Suite REST API

| Category | Tools |
|----------|-------|
| **Proxy** | `get_proxy_http_history`, `get_proxy_http_history_regex`, `get_proxy_websocket_history`, `get_proxy_websocket_history_regex`, `set_proxy_intercept_state` |
| **Scanner** | `burp_active_scan`, `burp_passive_scan`, `burp_get_scan_status`, `burp_cancel_scan`, `get_scanner_issues` |
| **Repeater** | `send_http1_request`, `send_http2_request`, `create_repeater_tab`, `replay_and_diff` |
| **Intruder** | `send_to_intruder`, `build_intruder_attack` |
| **Collaborator** | `generate_collaborator_payload`, `get_collaborator_interactions` |
| **Encodin

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [HyperPS](https://github.com/HyperPS)
- **Source:** [HyperPS/kali-burp-mcp-bridge](https://github.com/HyperPS/kali-burp-mcp-bridge)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-hyperps-kali-burp-mcp-bridge
- Seller: https://agentstack.voostack.com/s/hyperps
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.