Burp Discord Activity – Build a Burp Suite Extension with Discord Rich Presence

/**
 * Minimal Burp Suite Discord Rich Presence extension.
 * Vibe coded by @imXhandle | notrubberduck.space
 * Show off your Burp Suite work on Discord with style!
 */
public class BurpDiscordActivity implements BurpExtension, HttpHandler {

    private MontoyaApi api;
    private DiscordRPCManager discordRPC;
    private ScheduledExecutorService scheduler;
    private String lastHost = "None";
    private boolean isActive = false;
    private long lastActivityTime = 0;
    private boolean hasSeenTarget = false;
    private String projectName = "Untitled Project";
    private long lastUpdateTime = 0;
    private static final long UPDATE_THROTTLE_MS = 1000;
    private long requestCount = 0;
    private long lastTrafficCheck = 0;
    private long sessionStartTime = 0; // Track when Burp session started

    @Override
    public void initialize(MontoyaApi api) {
        this.api = api;
        this.sessionStartTime = System.currentTimeMillis(); // Start session timer

        // Manual project name extraction with error handling
        try {
            projectName = api.project().name();
            if (projectName == null || projectName.isEmpty()) {
                projectName = "Burp Project";
            }
        } catch (Exception e) {
            projectName = "Burp Project";
            api.logging().logToError("Could not get project name: " + e.getMessage());
        }

        discordRPC = new DiscordRPCManager(api.logging()::logToError);
        api.http().registerHttpHandler(this);
        api.extension().registerUnloadingHandler(() -> shutdown());

        // Manual scheduler setup with daemon threads
        scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
            Thread t = new Thread(r, "Discord-Updater");
            t.setDaemon(true);
            return t;
        });

        scheduler.scheduleAtFixedRate(this::updatePresence, 0, 30, TimeUnit.SECONDS);

        api.logging().logToOutput("Burp Discord Activity loaded - Project: " + projectName);
        api.logging().logToOutput("Vibe coded by @imXhandle | notrubberduck.space");
    }
}

@Override
public RequestToBeSentAction handleHttpRequestToBeSent(HttpRequestToBeSent request) {
    String host = request.httpService().host();
    if (host != null && !host.isEmpty()) {
        lastHost = host;
        hasSeenTarget = true;
        isActive = true;
        lastActivityTime = System.currentTimeMillis();

        // Manual scope detection
        boolean inScope = api.scope().isInScope(request.url());
        if (inScope) {
            lastHost = host;
        }

        // Hand-coded smart throttling based on traffic volume
        requestCount++;
        long currentTime = System.currentTimeMillis();

        // Reset traffic counter every 10 seconds
        if ((currentTime - lastTrafficCheck) > 10000) {
            requestCount = 0;
            lastTrafficCheck = currentTime;
        }

        // Manual throttle adjustment based on traffic analysis
        long throttleTime = UPDATE_THROTTLE_MS;
        if (requestCount > 100) {
            throttleTime = 3000; // Heavy traffic
        } else if (requestCount > 50) {
            throttleTime = 2000; // Medium traffic
        }

        if ((currentTime - lastUpdateTime) > throttleTime) {
            lastUpdateTime = currentTime;
            updatePresence();
        }
    }
    return RequestToBeSentAction.continueWith(request);
}

/**
 * Simple Discord Rich Presence manager.
 * Vibe coded by @imXhandle | notrubberduck.space
 * Professional Discord integration for Burp Suite
 */
public class DiscordRPCManager {
    private static final String CLIENT_ID = "1457114543028437112";

    private final DiscordRPC rpc;
    private final AtomicBoolean connected = new AtomicBoolean(false);
    private final ScheduledExecutorService scheduler;
    private final Consumer<String> errorLogger;
    private String lastStatus = "";
    private String lastHost = "";

    public DiscordRPCManager(Consumer<String> errorLogger) {
        this.rpc = DiscordRPC.INSTANCE;
        this.scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
            Thread t = new Thread(r, "DiscordRPC");
            t.setDaemon(true);
            return t;
        });
        this.errorLogger = errorLogger;

        connect();
    }

    private void connect() {
        try {
            DiscordEventHandlers handlers = new DiscordEventHandlers();
            handlers.ready = (user) -> connected.set(true);
            handlers.disconnected = (errorCode, message) -> connected.set(false);

            // Manual Discord initialization with proper parameters
            rpc.Discord_Initialize(CLIENT_ID, handlers, true, null);
            connected.set(true);

            // Keep connection alive with manual callback scheduling
            scheduler.scheduleAtFixedRate(rpc::Discord_RunCallbacks, 0, 2, TimeUnit.SECONDS);

        } catch (Exception e) {
            errorLogger.accept("Failed to connect to Discord: " + e.getMessage());
        }
    }

    public void updatePresence(String status, String host, String projectName, long sessionStartTime) {
        // Vibe coded by @imXhandle | notrubberduck.space
        // Skip duplicate updates for performance
        if (status.equals(lastStatus) && host.equals(lastHost)) {
            return;
        }

        lastStatus = status;
        lastHost = host;

        if (!connected.get()) return;

        try {
            DiscordRichPresence presence = new DiscordRichPresence();
            presence.details = projectName; // Project name as main title

            // Add game timer (start timestamp) but no custom session timer text
            presence.startTimestamp = sessionStartTime;

            // Clean display without custom session timer
            if (host.equals("None") || host.isEmpty()) {
                presence.state = status + " • No target";
            } else {
                presence.state = status + " • " + host;
            }

            presence.largeImageKey = "burpsuite_icon";
            presence.largeImageText = "Burp Suite by @imXhandle";

            rpc.Discord_UpdatePresence(presence);
        } catch (Exception e) {
            connected.set(false);
            errorLogger.accept("Failed to update Discord: " + e.getMessage());
        }
    }
}

// Manual data flow implementation
1. HTTP Request → Burp Suite HttpHandler
2. Extract host and check scope manually
3. Apply smart throttling based on traffic analysis
4. Update Discord Rich Presence with project name
5. Handle connection errors gracefully
6. Display results in Discord desktop app

// Manual tool detection through URL patterns and scope analysis
private boolean isInScope(String url) {
    return api.scope().isInScope(url);
}

// Manual traffic analysis and throttling
if (requestCount > 100) {
    throttleTime = 3000; // Reduce updates during heavy traffic
}

// Keep Discord connection alive manually
scheduler.scheduleAtFixedRate(rpc::Discord_RunCallbacks, 0, 2, TimeUnit.SECONDS);

// Simplified component diagram
BurpDiscordActivity (Main)
├── DiscordRPCManager (Communication)
│   ├── DiscordRPC rpc
│   ├── AtomicBoolean connected
│   └── ScheduledExecutorService scheduler
├── HttpHandler Implementation
│   ├── Smart throttling logic
│   ├── Scope detection
│   └── Traffic analysis
└── ToolState (Constants)
    ├── PROXY, IDLE
    └── display name mappings

private void updatePresence() {
    // Vibe coded by @imXhandle | notrubberduck.space
    // Manual idle detection (5 minutes = 300000 ms)
    long now = System.currentTimeMillis();
    if (isActive && (now - lastActivityTime) > 300000) {
        isActive = false;
    }

    String status = isActive ? "Proxy" : "Idle";

    // Always show the last target we've seen, even when idle
    String targetToShow = hasSeenTarget ? lastHost : "None";
    discordRPC.updatePresence(status, targetToShow, projectName, sessionStartTime);
}

# Manual pentesting session with Discord updates
1. Start Burp Suite with extension loaded
2. Begin proxying traffic through target application
3. Discord shows: "Client Project • Proxy • target.com"
4. Switch targets → Discord shows "Client Project • Proxy • new.target.com"
5. Run automated scan → Extension handles 1000+ requests smoothly
6. Go idle for 5 minutes → Discord shows "Client Project • Idle • target.com"
7. Discord game timer shows elapsed session time

// Manual team coordination through Discord presence
{
    "details": "Client Assessment Project",
    "state": "Proxy • api.target.com",
    "timestamps": {
        "start": 1641024000000
    },
    "assets": {
        "large_image": "burpsuite_icon",
        "large_text": "Burp Suite by @imXhandle"
    }
}

// Real traffic throttling implementation (from actual code)
// Smart throttling based on traffic volume
requestCount++;
long currentTime = System.currentTimeMillis();

// Reset traffic counter every 10 seconds
if ((currentTime - lastTrafficCheck) > 10000) {
    requestCount = 0;
    lastTrafficCheck = currentTime;
}

// Adjust throttle based on traffic volume
long throttleTime = UPDATE_THROTTLE_MS;
if (requestCount > 100) {
    throttleTime = 3000; // 3 seconds for heavy traffic
} else if (requestCount > 50) {
    throttleTime = 2000; // 2 seconds for medium traffic
}

if ((currentTime - lastUpdateTime) > throttleTime) {
    lastUpdateTime = currentTime;
    updatePresence();
}

// Real resource cleanup (from actual code)
private void shutdown() {
    if (scheduler != null) scheduler.shutdown();
    if (discordRPC != null) discordRPC.shutdown();
    api.logging().logToOutput("Burp Discord Activity unloaded - @imXhandle | notrubberduck.space");
}

// Real error handling for Discord (from actual code)
try {
    DiscordRichPresence presence = new DiscordRichPresence();
    presence.details = projectName;
    presence.startTimestamp = sessionStartTime;
    presence.state = status + " • " + host;
    presence.largeImageKey = "burpsuite_icon";
    presence.largeImageText = "Burp Suite by @imXhandle";
    rpc.Discord_UpdatePresence(presence);
} catch (Exception e) {
    connected.set(false);
    errorLogger.accept("Failed to update Discord: " + e.getMessage());
}

// Real API error handling (from actual code)
try {
    projectName = api.project().name();
    if (projectName == null || projectName.isEmpty()) {
        projectName = "Burp Project";
    }
} catch (Exception e) {
    projectName = "Burp Project";
    api.logging().logToError("Could not get project name: " + e.getMessage());
}