> your AI agent picks dependencies from memory; give it dated facts — try starlog.dev ↗ vet your agent's deps ↗ vibe-coding is fine. vibe-importing isn’t. — try starlog.dev ↗ vibe-importing isn’t fine ↗ your agent has never seen your private packages — try starlog.dev ↗ facts for private packages ↗ a linter for the dependencies your AI agent picks — try starlog.dev ↗ a linter for agent deps ↗ whois is redacted, cdns mask the rest — get the real operator — try whoisgeni.us ↗ who really runs that domain ↗ domain attribution that shows its work — full evidence chain — try whoisgeni.us ↗ domain intel w/ evidence ↗

← Back to Articles

Building an MCP Bridge Between Burp Suite and Claude: Security Testing with LLM Assistance

[ View on GitHub ]

Building an MCP Bridge Between Burp Suite and Claude: Security Testing with LLM Assistance

Hook

What if your penetration testing proxy could explain vulnerabilities in natural language, or let you ask 'show me all requests with potential SQLi vectors' without writing a single line of Python?

Context

Burp Suite has dominated web security testing for nearly two decades, but its capabilities are locked behind a GUI and Java API. Meanwhile, LLMs like Claude have become surprisingly competent at analyzing security patterns—spotting injection flaws in HTTP traffic, explaining vulnerability chains, even suggesting exploitation techniques. The problem? These worlds don't talk to each other.

The Model Context Protocol (MCP) emerged as Anthropic's solution for connecting LLMs to external data sources and tools, but it was designed for stdio transports—perfect for command-line tools Claude spawns as child processes, terrible for long-running GUI applications like Burp. You can't just pipe stdin/stdout to a proxy that needs to maintain persistent state across thousands of HTTP requests. danielgallen/mcp-server solves this impedance mismatch by building a two-component architecture: a Kotlin extension running inside Burp that exposes an SSE endpoint, and a lightweight proxy JAR that translates between Claude's stdio expectations and the extension's HTTP reality.

Technical Insight

Burp Suite JVM

Proxy Daemon

Desktop Process

stdio

SSE HTTP

Tool calls

Proxy history

Scanner results

MCP responses

stdio

Claude Desktop

mcp-proxy

stdio-to-SSE

Burp Extension

MCP Server

Burp Suite API

System architecture — auto-generated

The architecture is clever precisely because it acknowledges the constraints of both systems. Burp extensions run in-process as JVM plugins with access to internal APIs, while Claude Desktop only knows how to spawn stdio processes defined in its config JSON. The solution splits the problem: the Burp extension hosts an MCP server over Server-Sent Events on localhost:9876, and a separate mcp-proxy daemon acts as a translation layer.

Here's what a tool definition looks like in the extension's Kotlin code:

@Serializable
data class ProxyHistoryParams(
    val filter: String? = null,
    val limit: Int = 100,
    val offset: Int = 0
) : PaginatedParams

object ProxyHistoryTool : Tool, Paginated {
    override val name = "get_proxy_history"
    override val description = "Retrieve HTTP requests/responses from Burp's proxy history"
    
    override suspend fun execute(params: JsonObject): ToolResult {
        val typed = Json.decodeFromJsonElement<ProxyHistoryParams>(params)
        val entries = burp.proxy().history()
            .filter { entry -> 
                typed.filter?.let { entry.url().contains(it) } ?: true
            }
            .drop(typed.offset)
            .take(typed.limit)
        
        return ToolResult.success(
            entries.joinToString("\n") { "${it.method()} ${it.url()}" }
        )
    }
}

Notice the data class with serialization annotations—MCP tool schemas are auto-generated from Kotlin's type system. Add a parameter, and the JSON schema exposed to Claude updates automatically. No manual schema maintenance. The PaginatedParams interface is a mixin that every paginated tool inherits, providing consistent offset/limit handling across large datasets like proxy logs.

The SSE server implementation uses Ktor under the hood, maintaining long-lived connections where the client (mcp-proxy) sends tool invocation requests and the server streams back results. This is crucial for Burp's event-driven architecture—scan results arrive asynchronously, and SSE naturally models that flow.

The proxy component is intentionally minimal, around 150 lines of Java that reads from stdin, forwards HTTP requests to localhost:9876, and writes responses back to stdout:

// Simplified proxy logic
fun main() {
    val client = HttpClient(CIO) {
        install(SSE)
    }
    
    runBlocking {
        client.sse("http://localhost:9876/sse") {
            launch { 
                // Read stdin, send as HTTP POST
                generateSequence(::readLine).forEach { line ->
                    send(line)
                }
            }
            
            incoming.collect { event ->
                // Forward SSE events to stdout
                println(event.data)
            }
        }
    }
}

The auto-installer is where this gets audacious. Rather than making users manually edit ~/Library/Application Support/Claude/claude_desktop_config.json, the extension includes a UI toggle that directly modifies the file:

fun installMCPConfig() {
    val configPath = when {
        System.getProperty("os.name").contains("Mac") -> 
            "~/Library/Application Support/Claude/claude_desktop_config.json"
        else -> "~/.config/Claude/claude_desktop_config.json"
    }
    
    val config = Json.parseToJsonElement(File(configPath).readText())
        .jsonObject.toMutableMap()
    
    config["mcpServers"] = buildJsonObject {
        putJsonObject("burp") {
            put("command", "java")
            putJsonArray("args") {
                add("-jar")
                add("${extensionJarPath}/mcp-proxy.jar")
            }
        }
    }
    
    File(configPath).writeText(Json.encodeToString(config))
}

This removes the biggest adoption barrier—most developers would abandon the setup after seeing a 10-step configuration guide. The security implications are interesting: the extension ships with the proxy JAR embedded via Gradle's shadow plugin, making distribution a single file, but also meaning the extension can write arbitrary JSON to Claude's config. The opt-in toggle acknowledges this isn't something you'd enable blindly.

Tool execution happens through Burp's native APIs. The sendToRepeater tool wraps Burp's Repeater tab API, letting Claude programmatically load requests for manual modification. The activeScan tool triggers Burp Scanner's crawler and audit engine—potentially expensive operations with no rate limiting. This is where the 'LLM as security assistant' vision gets real: you can ask Claude to 'scan all POST endpoints for SQLi' and it orchestrates Burp's tooling through natural language.

The pagination implementation deserves attention because it solves a real problem with LLM context limits. Proxy histories routinely contain 10,000+ entries. Rather than dumping everything in a single tool response, paginated tools return metadata about total results and support offset-based chunking. Claude learns to make multiple tool calls, requesting subsequent pages as needed.

Gotcha

The localhost-only architecture with zero authentication is the elephant in the room. Any process on your machine can connect to port 9876 and invoke tools—including malicious Chrome extensions, compromised npm packages in your dev environment, or even other LLMs if you're running multiple AI assistants. There's no API key, no token validation, not even a capability-based security model. The assumption is 'my local machine is my security boundary,' which might be fine for personal security research but unacceptable in shared or CI environments.

The stdio proxy introduces a failure mode you wouldn't have with native integrations. If the Java child process crashes—maybe from heap exhaustion or a coroutine deadlock—Claude loses all Burp connectivity with no automatic recovery. You have to restart Claude Desktop to respawn the proxy. There's also latency overhead: every tool invocation crosses process boundaries twice (Claude → proxy → extension) and includes JSON serialization at each hop. For high-frequency operations like monitoring real-time traffic, this adds perceptible lag. Finally, extending the tool set requires Kotlin expertise and recompiling the extension JAR. There's no plugin system for adding custom tools without forking the repo, which limits adoption among teams with specialized workflows beyond the built-in proxy/scanner/repeater operations.

Verdict

Use if: You're a security researcher or penetration tester who regularly uses Burp Suite and wants to experiment with LLM-assisted analysis—letting Claude sift through proxy logs, explain vulnerability patterns, or orchestrate scanning workflows through conversation. The auto-installer and single-JAR distribution make this the lowest-friction way to connect Claude to live HTTP traffic, and the Kotlin codebase is clean enough to fork if you need custom tools for your team's workflow. It's particularly valuable if you're tired of writing throwaway Python scripts to parse Burp's state files and want a more flexible interface. Skip if: You need multi-user deployments, remote access, or any production security controls—this is fundamentally a localhost developer tool with an attack surface shaped like 'whoever can reach TCP 9876.' Also skip if you're building integrations around other proxies like mitmproxy or ZAP, since the architecture is Burp-specific and doesn't generalize. If you need custom tooling beyond basic proxy/scanner operations, consider Burp's REST API with a custom MCP server instead—you'll have more control over security boundaries and won't be locked into the extension's update cycle.