Some of the most impactful vulnerabilities in web applications are blind — the application processes your input, something happens on the backend, but you never see the result in the HTTP response. Blind XSS, blind SSRF, and blind XXE all fall into this category. To detect them, you need a server that's listening for callbacks: an out-of-band (OOB) testing server.

I built one. It runs on the same VPS as this site — 9mmpterodactyl.com — and it's been up continuously for over five months. This post covers what it does, how it's built, and why the same pattern applies to defensive security monitoring.

The Problem

Take blind XSS as an example. You inject a payload into a form field — say, a support ticket or a feedback form. The payload doesn't execute in your browser. It sits in a database until someone on the backend opens it: an admin viewing tickets, a moderator reviewing reports, a developer checking logs. When that person's browser renders your payload, it fires. But you're not there to see it.

The same goes for blind SSRF. You submit a URL that the server fetches internally — maybe through a webhook, an image preview, a PDF generator, or an import function. The server makes the request, but you don't see the response. You need to know whether the request happened at all, when it happened, and what information it carried.

The solution is a callback server. Your payload includes a URL pointing at a server you control. If the vulnerability fires, the target system reaches out to your server, and you catch the request. The request itself — its timing, headers, source IP, and path — tells you what happened.

How It Works

The server is built on nginx. I configured specific endpoints that log incoming requests in detail — not just the standard access log, but the full request including headers, query parameters, and the exact path that was hit.

The logging configuration captures everything I need to identify which payload triggered, when it fired, and from where. Each test gets its own unique endpoint path, so when a callback comes in, I can trace it back to the exact injection point.

For example, if I'm testing a support ticket form on a target, the payload might include a reference to https://9mmpterodactyl.com/cb/target-name/ticket-field. When an admin opens that ticket and the blind XSS fires, their browser makes a request to that path. My nginx logs record the hit with a timestamp, the source IP (which tells me it came from the target's internal network or an admin's browser), and the full request details.

The Python Parser

Raw nginx logs are usable but not convenient. I wrote a custom Python log-parsing tool that processes the callback logs and presents them in a way that's actually useful during active testing.

The parser reads the nginx log output and extracts the relevant fields: the callback path (which identifies the test), the timestamp, the source IP, the User-Agent header, and any other data carried in the request. This lets me quickly see which payloads have fired across all active tests without manually grepping through log files.

The tooling is intentionally simple. It's a Python script that reads structured log data and outputs what I need. No web framework, no database, no dashboard — just a parser that turns raw logs into actionable information.

The Defensive Angle

Here's the thing about this setup: it's the exact same pattern that underlies most defensive security monitoring. Collect structured event data, parse it, look for signals that matter, and surface them.

An OOB testing server collects callback events and looks for hits that indicate a vulnerability fired. A SIEM collects log events from across an environment and looks for patterns that indicate an attack or anomaly. The difference is scope and intent, not architecture.

The skills transfer directly:

  • Log collection and structured logging. Configuring nginx to capture the right data in a parseable format is the same problem as configuring any log source to feed a monitoring pipeline. What you capture and how you structure it determines what questions you can answer later.
  • Event parsing and normalization. My Python parser does the same thing a log parser in a SIEM does — take raw event data in one format and extract the fields that matter for analysis. Whether you're parsing nginx access logs, Windows Event Logs, or firewall logs, the pattern is identical: read structured text, extract fields, normalize values, and make them queryable.
  • Signal detection. On the offensive side, I'm looking for "did this callback fire?" On the defensive side, the equivalent is "did this alert trigger?" or "does this log pattern match a known attack signature?" Both are the same question: does this event data contain evidence of something I care about?
  • Infrastructure management. The server has to be up, has to be reachable, and has to be logging correctly at all times. If it's down when a blind XSS fires three days after injection, I miss the callback. The same reliability requirement applies to any monitoring infrastructure — if your collector is down during an incident, you have a gap in your telemetry.

Operational Details

The server runs on a VPS that I provision and administer myself. It's the same host that serves this portfolio site. The setup includes TLS, firewall rules, key-only SSH access, and regular patching — the same hardening I'd apply to any internet-facing server.

Five months of continuous uptime so far. That matters because blind vulnerabilities can take days, weeks, or longer to fire. A payload injected into a quarterly report form might not trigger until someone opens that report months later. The server needs to be there when it does.

Why Build Your Own

There are commercial and open-source OOB tools available. I built my own because I wanted to understand the full chain — from the raw HTTP request arriving at nginx, through the log pipeline, to the parsed output. Using someone else's tool gives you results; building your own gives you understanding.

It also means I control the infrastructure completely. I know exactly what's being logged, where it's stored, how long it's retained, and who has access. For bug bounty work where you're handling data from targets, that control matters.

And the skills I built doing this — server provisioning, nginx configuration, log pipeline design, Python tooling — are directly useful in both offensive and defensive security work. It's not just a testing tool; it's a training ground.

← Back to Blog Project Details →