Zurp: Meta's Multi-Actor Security Testing Proxy for Vetted Bug Bounty Researchers
Hook
Most security proxies fail multi-actor testing the moment you try to simulate an attacker and victim in different browser tabs—their CSRF token stores overwrite each other. Meta built Zurp specifically to fix this.
Context
If you've ever tried to test a CSRF vulnerability where an attacker tricks a victim into performing an action, you've hit the token management problem: your intercepting proxy captures the victim's CSRF token, then overwrites it when you switch to the attacker tab. Burp's session handling rules are global per-project, so you end up running multiple Burp instances or manually swapping tokens in macros. The problem compounds when testing Meta's products, which use multiple anti-CSRF mechanisms (fb_dtsg, lsd, jazoest) that must stay consistent across request replay, and where internal identifiers like entity IDs need resolution to understand what you're actually testing.
Zurp emerged from Meta's Bug Bounty program to address the specific friction points vetted researchers encounter when testing at scale on Meta properties. Rather than building a monolithic security testing framework, Meta released a collection of independent tools unified by a single authentication model: a Burp Suite extension for request-path manipulation and MCP (Model Context Protocol) servers that expose the same capabilities to AI agents. The design philosophy is pragmatic—each tool solves one problem well, gates on Meta's existing FBDL allowlist for vetted researchers, and requires zero coordination with the other tools. This isn't tooling for everyone; it's opinionated infrastructure for researchers who already have 10+ accepted Meta bugs and need to move faster on Meta-specific workflows.
Technical Insight
The core architectural insight in Zurp is its per-account-per-host token store design. Instead of maintaining a single CSRF token per session or per project, the Burp extension tracks tokens keyed by both hostname and account identifier. When you browse Meta properties logged into multiple accounts across different tabs, Zurp passively scrapes CSRF tokens from responses and indexes them separately. When you replay a request, it substitutes the correct token based on which account initiated that specific request flow.
Here's how the token substitution works in practice. Say you're testing a vulnerability where Alice (victim) and Bob (attacker) interact. You browse Facebook logged in as Alice in one tab, generating traffic that flows through Burp. Zurp's passive scanner extracts fb_dtsg, lsd, and jazoest from the responses and stores them under Alice's account identifier for facebook.com. Then you switch to Bob's tab—different browser profile, different cookies—and generate more traffic. Zurp creates a separate token store entry for Bob's facebook.com tokens. Now when you replay Alice's captured request from Burp's Proxy history, Zurp automatically injects Alice's tokens, not Bob's. The extension performs this substitution at request-send time:
// Conceptual illustration of token substitution logic
public HttpRequest processProxyRequest(HttpRequest request) {
String host = request.httpService().host();
String accountId = extractAccountIdentifier(request);
TokenStore tokens = tokenCache.get(host, accountId);
if (tokens == null) {
return request; // No stored tokens, pass through
}
String body = request.bodyToString();
body = body.replaceAll("fb_dtsg=[^&]*", "fb_dtsg=" + tokens.fbDtsg);
body = body.replaceAll("lsd=[^&]*", "lsd=" + tokens.lsd);
body = body.replaceAll("jazoest=[^&]*", "jazoest=" + tokens.jazoest);
return request.withBody(body);
}
This is implemented as request-path rewriting rather than session handling rules, which means it's architectural—it happens automatically on every request without requiring macros or manual intervention. The substitution logic never overwrites your original captured request; it creates a new request with updated tokens on the fly. This is crucial for multi-actor scenarios where you're replaying the same baseline request with different account contexts.
The second surface is the MCP server implementation, which is a complete rewrite in Node.js with zero shared code from the Java extension. This was a deliberate choice: AI agents don't run in the JVM, and the interaction model is fundamentally different. Instead of passively enriching HTTP traffic, the MCP servers expose explicit tool calls over stdio. An agent can invoke meta_context_resolve with an entity ID and get back structured JSON with the entity type and internal name, or call fbdl_provision to spin up test accounts for a specific scenario.
The MCP servers call the same internal Meta APIs as the Burp extension, but they lack the request-path advantages. An agent can't benefit from automatic token substitution because there's no HTTP interception layer—it's just a stdio conversation. This means agents have to manage token expiration themselves and explicitly request fresh tokens when needed. The tradeoff is worth it: agents get structured, parseable responses instead of having to scrape annotated HTTP traffic.
One of the most practical features is FBDL script pinning, which transforms ephemeral test environments into reusable fixtures. Bug bounty researchers often spin up test accounts and assets (pages, groups, events) for specific vulnerability scenarios, but these environments expire or get cleaned up. Zurp lets you reference FBDL provisioning scripts with placeholder syntax like {{fbdl.runID.PageOne}} in your saved requests. When you send the request, Zurp resolves the label to the current entity ID from your most recent FBDL run. If you need to re-test a month later, you re-run the FBDL script to provision fresh assets, and all your saved requests automatically point to the new entities. No more manually updating dozens of request templates with expired IDs.
The authentication model is brilliantly simple: one token for everything. You generate a Meta access token while logged into an account that's enrolled in FBDL (which requires 10+ accepted bugs). That single token authorizes both the Burp extension's API calls and the MCP server operations. There's no separate API key management, no OAuth flow, no token rotation between tools. The allowlist gating happens server-side at Meta—if your account isn't enrolled in FBDL, the token minting fails. This eliminates the authentication/authorization complexity that kills most security tool projects. Meta already maintains the allowlist for their bug bounty program, so Zurp just piggybacks on that existing trust boundary.
The extension deliberately avoids bundling dependencies beyond the Montoya API, relying on Burp's runtime to supply implementations. This prevents version shadowing bugs where the extension's bundled library conflicts with Burp's own dependencies, but it also means Zurp is genuinely Burp-specific. You can't extract the token management logic and run it in ZAP or Caido without rewriting the entire proxy integration layer. The tradeoff is intentional: tight coupling to Burp's runtime in exchange for zero dependency hell.
Gotcha
The biggest gotcha is the FBDL enrollment gate. If you don't have 10+ accepted Meta bugs, you can't generate the authentication token, which means the entire toolchain is inaccessible. There's no trial mode, no reduced-functionality version for new researchers, no alternative credential mechanism. This is by design—Meta wants these tools in the hands of vetted researchers only—but it creates a chicken-and-egg problem. New researchers can't use Zurp to help them find their first 10 bugs because they need 10 bugs to access Zurp.
The second major limitation is token minting failure modes. If you're logged into the wrong account when you generate the token, you get opaque 403 errors with no indication of which account was rejected or why. The documentation acknowledges this as 'the most common setup problem by a wide margin,' but there's no programmatic fix. You have to manually verify you're logged into the correct account, clear cookies, and try again. The CSRF token scraping is entirely passive—it only works if you browse normally and generate responses that contain tokens. If you start testing immediately after loading the extension, your first few requests will fail because the token store is empty. There's no explicit 'seed this account' operation to pre-populate tokens; you just have to generate some legitimate traffic first. Finally, there's no integration between tools. SPARTA surfaces security leads, but you can't automatically send them to Repeater or chain them into test cases. FBDL provisions test accounts, but you have to manually configure Burp's browser to use them. The tools share authentication but not workflow state, so you're still doing the orchestration yourself.
Verdict
Use if: You're already enrolled in Meta's Bug Bounty program with 10+ accepted bugs, spend significant time testing Meta properties specifically, and regularly encounter multi-actor testing scenarios where per-account CSRF token management would save hours of manual work. The FBDL script pinning alone justifies adoption if you maintain collections of saved requests that break every time test assets expire. The MCP servers are valuable if you're experimenting with agent-driven reconnaissance and want structured access to Meta's internal resolution APIs without writing your own API clients. Skip if: You're new to bug bounty hunting on Meta (you won't have the required credentials), testing non-Meta properties (the tools are Meta-specific), or satisfied with Burp's built-in session handling rules for simple single-actor scenarios. Also skip if you use ZAP or Caido exclusively—Zurp is tightly coupled to Burp Suite and won't port cleanly to other proxies. The narrow focus is the point: this isn't general-purpose tooling, it's infrastructure for a specific vetted community, and its value is directly proportional to how deeply you work within that context.