Skip to content
Back to Articles

Listed for Phishing, but the Phishing Page Isn't There: Triaging Blocklist Reports and Catch-All URLs

Share:

A site owner gets an email: their domain is on a public blocklist for phishing. The report names one URL, something like https://example.com/mygov/ or https://example.com/wp-content/xyz/login/. They open it in a browser and it loads. HTTP 200. An automated check even says the page "contains a password field". So the phishing page must be there.

Except it isn't. There is no mygov folder on the server, no fake government login, no stolen-credentials mailer. The URL loads because the site answers every path with its homepage, and the "password field" is a line of CSS that styles the login box of the theme. Both signals are real. Neither one means phishing.

This article is a step-by-step triage method for that situation. It is for site owners, hosting administrators and analysts who receive a threat-feed or blocklist report that names a specific URL. Every command is read-only and can be copied as is. The examples use example.com and documentation IP ranges. Replace them with the URL from your report.

🧭 The short version

  • HTTP 200 is not proof that a page exists. Many WordPress themes, single-page apps and server rules return the homepage for any path (a "soft 404"), or redirect every unknown path to the homepage.
  • Compare three fetches: the reported URL, a random path that cannot exist, and the homepage. If all three come back the same, the reported path is not a separate page.
  • A "password" string is not a login form. Only a real <input type="password"> element in the served HTML counts. CSS selectors, JavaScript and translation strings do not.
  • A clean result is not a full answer. Phishing kits often show their page only to some visitors. Check the server side too: files under the reported path, recent changes, and the access log for that path.
  • A listing is history. The page may have existed and been removed already. What the URL returns today does not tell you what it returned on the day it was listed.

🪞 Why a missing page can return HTTP 200

A well-behaved site answers a request for a page that does not exist with 404 Not Found. A lot of real sites do something else, and usually on purpose:

  • Soft 404. The application catches every path and renders the homepage (or a generic template) with status 200. Some themes and page builders do this. So do single-page apps whose server sends index.html for any path so the JavaScript router can decide what to show.
  • Redirect-everything. Unknown paths get a 301 or 302 to the homepage. "Redirect 404 to homepage" is a common SEO plugin setting on WordPress, and it can also be done with one rewrite rule in .htaccess or the nginx config.
  • Slug guessing. WordPress itself tries to guess what you meant when a URL is not found. If a post or page slug starts with the same words, WordPress may send a 301 to that post. A request for /mygov can end up on /my-government-grant-guide/, a real and harmless blog post.
  • Query strings on the homepage. A reported URL like /?login=verify or /index.php?mygov is simply the homepage with a parameter the site ignores.

None of this is a security problem. But a naive check, whether a person clicking a link or a script that only looks at the status code, sees "the URL works" and concludes "the phishing page is live". That is how a catch-all site ends up looking guilty.

🧪 Step 1: Fetch the reported URL, a random path and the homepage

Set three variables. The random path uses 16 hex characters, so it cannot be a real page on any site.

SITE="https://example.com"
REPORTED="https://example.com/mygov/"
RANDOM_URL="$SITE/$(openssl rand -hex 8)/"
echo "$RANDOM_URL"

Now look at the status code and the redirect target of each, first without following redirects and then following them:

for u in "$SITE/" "$REPORTED" "$RANDOM_URL"; do
curl -s -o /dev/null -A "Mozilla/5.0" -w "%{http_code}  redirect=%{redirect_url}  $u\n" "$u"
done
echo "--- following redirects ---"
for u in "$SITE/" "$REPORTED" "$RANDOM_URL"; do
curl -s -L -o /dev/null -A "Mozilla/5.0" -w "%{http_code}  %{size_download} bytes  hops=%{num_redirects}  final=%{url_effective}\n" "$u"
done

Typical output on a site that redirects every unknown path:

200  redirect=  https://example.com/
302  redirect=https://example.com/  https://example.com/mygov/
302  redirect=https://example.com/  https://example.com/5d1c0e8a9f3b2a71/
--- following redirects ---
200  48213 bytes  hops=0  final=https://example.com/
200  48213 bytes  hops=1  final=https://example.com/
200  48213 bytes  hops=1  final=https://example.com/

The reported path and a path that cannot exist behave exactly the same way. Both end on the homepage. On a soft-404 site you would see three 200 responses with no redirect and near-identical sizes instead. Sizes can differ by a few bytes, because pages often carry a random nonce or a timestamp, so do not expect an exact match.

Save the three bodies for the next steps. This writes to a folder in your own home directory, not on the website.

mkdir -p ~/blocklist-triage && cd ~/blocklist-triage
curl -s -L -A "Mozilla/5.0" "$SITE/" -o home.html
curl -s -L -A "Mozilla/5.0" "$REPORTED" -o reported.html
curl -s -L -A "Mozilla/5.0" "$RANDOM_URL" -o random.html
ls -l home.html reported.html random.html

📏 Step 2: Measure how similar the pages are

Eyeballing two 50 KB HTML files does not work. The snippet below uses only the Python standard library. It strips scripts, styles and tags, splits the visible text into words, builds the set of all 4-word sequences ("shingles") for each page, and computes the Jaccard similarity: shared shingles divided by all shingles. It also prints each page's size and <title>.

python3 - home.html reported.html random.html <<'EOF'
import html, os, re, sys

def read(path):
    return open(path, encoding="utf-8", errors="replace").read()

def title(text):
    m = re.search(r"(?is)<title[^>]*>(.*?)</title>", text)
    return " ".join(html.unescape(m.group(1)).split()) if m else "(no title)"

def shingles(text, n=4):
    text = re.sub(r"(?is)<(script|style)\b.*?</\1>", " ", text)
    text = re.sub(r"(?s)<[^>]+>", " ", text)
    words = re.findall(r"\w+", html.unescape(text).lower())
    return {" ".join(words[i:i + n]) for i in range(max(len(words) - n + 1, 1))}

def jaccard(a, b):
    return len(a & b) / max(len(a | b), 1)

home, reported, rnd = sys.argv[1:4]
pages = {p: read(p) for p in (home, reported, rnd)}
sh = {p: shingles(t) for p, t in pages.items()}
for p, t in pages.items():
    print(f"{p:14} {os.path.getsize(p):>9} bytes  title: {title(t)}")
print()
print(f"reported vs home   : {jaccard(sh[reported], sh[home]):.2f}")
print(f"reported vs random : {jaccard(sh[reported], sh[rnd]):.2f}")
print(f"home     vs random : {jaccard(sh[home], sh[rnd]):.2f}")
EOF

On a catch-all site the result looks like this:

home.html          48213 bytes  title: Example Bakery | Fresh bread daily
reported.html      48213 bytes  title: Example Bakery | Fresh bread daily
random.html        48190 bytes  title: Example Bakery | Fresh bread daily

reported vs home   : 0.98
reported vs random : 0.99
home     vs random : 0.98

How to read it:

  • Reported vs random ≥ 0.9, same title: the reported path is whatever the site serves for any path. There is no separate page there today.
  • Reported vs home ≥ 0.9 but reported vs random low: the site has a real 404 page, yet the reported path renders the homepage. Look for a rewrite rule or redirect that targets this path specifically. That is unusual and worth a closer look.
  • Reported is low against both: the reported path is its own page. Go to Step 3 and Step 4 and treat it as a possible real hit.

One trap: if the reported URL is the bare homepage (https://example.com/), comparing it with home.html always gives 1.00, because it is the same request. That proves nothing. Compare it with the random path instead, and then check the homepage itself for a real login form in Step 3. A homepage can be phishing too, for example when an attacker replaced index.php.

🔑 Step 3: Is there really a password field?

Many automated checks flag a page because the word "password" appears in it. On a normal website that word is everywhere:

  • CSS rules such as input[type="password"]{...} in the theme stylesheet, often inlined into every page;
  • translation strings like "Lost your password?" or "Show password" in a JavaScript object;
  • a "My account" link or a hidden login modal for customers of a shop.

A quick grep shows where the word actually comes from:

grep -c -i 'password' reported.html
grep -o -i -E '.{0,40}password.{0,40}' reported.html | head -20
2
<style>input[type="password"]{border:1px solid #ccc;padding:6px}</s
<script>var i18n={"lost_password":"Lost your password?","show_password":

Neither line is a form field. What counts is a real <input type="password"> element in the HTML the server sent. Python's built-in html.parser treats the contents of <script> and <style> as raw text, so CSS selectors and JavaScript strings are never counted as elements. The snippet counts real password inputs, lists every form, and shows where each form sends its data:

python3 - reported.html "$REPORTED" <<'EOF'
import sys
from html.parser import HTMLParser
from urllib.parse import urljoin, urlsplit

path, page_url = sys.argv[1], sys.argv[2]
site_host = urlsplit(page_url).hostname

class FormFinder(HTMLParser):
    def __init__(self):
        super().__init__()
        self.forms, self.current, self.loose_pw = [], None, 0

    def handle_starttag(self, tag, attrs):
        a = {k: (v or "") for k, v in attrs}
        if tag == "form":
            action = urljoin(page_url, a.get("action", "").strip() or page_url)
            self.current = {"action": action, "method": a.get("method", "get").lower(), "pw": 0, "inputs": 0}
            self.forms.append(self.current)
        elif tag == "input":
            is_pw = a.get("type", "").strip().lower() == "password"
            if self.current is not None:
                self.current["inputs"] += 1
                self.current["pw"] += is_pw
            elif is_pw:
                self.loose_pw += 1

    def handle_endtag(self, tag):
        if tag == "form":
            self.current = None

f = FormFinder()
f.feed(open(path, encoding="utf-8", errors="replace").read())
total_pw = sum(x["pw"] for x in f.forms) + f.loose_pw
print(f"real <input type=password> elements: {total_pw} (outside any form: {f.loose_pw})")
for x in f.forms:
    host = urlsplit(x["action"]).hostname
    where = "same site" if host == site_host else f"OTHER HOST: {host}"
    print(f"form {x['method'].upper():4} pw={x['pw']} inputs={x['inputs']:<3} -> {x['action']}  [{where}]")
EOF

Catch-all homepage of a bakery:

real <input type=password> elements: 0 (outside any form: 0)
form GET  pw=0 inputs=1   -> https://example.com/  [same site]

A real credential-harvesting page looks very different:

real <input type=password> elements: 1 (outside any form: 0)
form POST pw=1 inputs=2   -> https://collector.example.net/next.php  [OTHER HOST: collector.example.net]

Two limits to keep in mind. First, a login form that JavaScript builds after the page loads will not appear in the raw HTML. If the page is mostly an empty <div> plus a large script, read the script. Second, a password field on your own WordPress login page (/wp-login.php) or shop account page is expected. The question is whether the field belongs to your site and posts to your site.

🎣 Step 4: When the report is real

Put the signals together. A real phishing page usually shows several of these at once:

  • it is a separate page: low similarity to both the homepage and the random path;
  • it has a real password input (or card number, one-time code, email + "continue");
  • it impersonates a brand that is not yours: a bank, a delivery company, a government portal, a webmail login, in the title, headings, button text or logo;
  • the form posts to another host, or to a PHP file next to the page (often called next.php, post.php, send.php or similar) that mails or forwards the data;
  • kit files sit nearby: a folder of images and CSS for the copied brand, a .zip of the kit, a text file where captured data is stored.

Check the visible branding quickly:

grep -oiE '<(h1|h2|h3|label|button)[^>]*>[^<]{1,120}' reported.html | head -30
grep -oiE '<(img|link)[^>]+(logo|icon)[^>]*>' reported.html | head -20

A clean fetch is not proof

Phishing kits often protect themselves. They show the fake page only to visitors from one country, only to mobile browsers, only when the visitor arrives from the link in the phishing email, or only once per IP address. Everyone else, including a security analyst and a site owner checking from their office, gets a redirect to a harmless site or a 404. So when Steps 1 to 3 come back clean, try a few different visitor profiles:

for ua in "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0 Safari/537.36" \
"Mozilla/5.0 (iPhone; CPU iPhone OS 18_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148" \
"curl/8.5.0"; do
curl -s -L -A "$ua" -e "https://mail.example.net/" -H "Accept-Language: en-US,en;q=0.9" \
-o /dev/null -w "%{http_code}  %{size_download} bytes  final=%{url_effective}\n" "$REPORTED"
done

Different sizes or final URLs for the same path are a strong hint that something on the server is making decisions about the visitor. Identical results still do not clear the site, because the kit may filter by IP or country. That is why the next part happens on the server.

Server-side checks (read-only)

These commands run on the web server over SSH as the site user (or with read access to the site files). They only list and read. Set DOCROOT to the folder that serves the domain: for example /home/USER/public_html on cPanel, /var/www/vhosts/example.com/httpdocs on Plesk, or the root in the nginx server block.

First, does the reported path exist on disk at all?

DOCROOT=/home/USER/public_html
ls -la "$DOCROOT/mygov" 2>&1
find "$DOCROOT" -maxdepth 3 -type d -iname '*mygov*' 2>&1 | head -50

"No such file or directory" plus a catch-all result from Step 2 is the common, benign outcome. If the folder exists, list everything in it before you touch anything.

Kits are usually dropped all at once, so recently modified files cluster together. List files changed in the last 30 days (adjust the window to the listing date):

find "$DOCROOT" -type f -mtime -30 \
\( -iname '*.php' -o -iname '*.htm*' -o -iname '*.js' -o -iname '*.zip' -o -iname '.htaccess' \) \
-not -path '*/cache/*' -printf '%TY-%Tm-%Td %TH:%TM  %8s  %p\n' | sort -r | head -200

On a migrated or restored site every file can carry the same date, so also search by content. The first search looks for chat-bot tokens used to send stolen data and for code that reads password-like POST fields. Legitimate login code matches too, so review each hit. The second and third look for visitor filtering in PHP and in .htaccess:

grep -rlE 'bot[0-9]{8,10}:[A-Za-z0-9_-]{30,}|\$_POST\[.(pass|passwd|password|pwd|otp|cc).\]' "$DOCROOT" \
--include='*.php' | grep -vE '/wp-(admin|includes)/' | head -200

grep -rnE 'HTTP_USER_AGENT|HTTP_REFERER|HTTP_ACCEPT_LANGUAGE|geoip|countryCode' "$DOCROOT" \
--include='*.php' | grep -vE '/wp-(admin|includes)/|/plugins/|/themes/' | head -100

grep -rnE 'RewriteCond +%\{(HTTP_USER_AGENT|HTTP_REFERER|REMOTE_ADDR)\}' "$DOCROOT" --include='.htaccess' | head -50

Then check the server's own routing, so you know why unknown paths return the homepage. On WordPress, the standard rewrite block in .htaccess sends every unknown path to index.php, and WordPress decides between a page and a 404. A FallbackResource, an ErrorDocument 404 pointing to the homepage, or an nginx try_files ... /index.html explains a soft 404. A blanket return 302 explains redirect-everything:

grep -nE 'FallbackResource|ErrorDocument|RewriteCond|RewriteRule' "$DOCROOT/.htaccess"
grep -rnE 'try_files|error_page|return +30[12]' /etc/nginx/ | head -50

On WordPress, also test the slug-guessing redirect described above. If /mygov redirects to a real post while a random path does not, that is the reason the reported URL "works":

curl -s -o /dev/null -w "%{http_code} -> %{redirect_url}\n" "$SITE/mygov"
curl -s -o /dev/null -w "%{http_code} -> %{redirect_url}\n" "$SITE/$(openssl rand -hex 8)"

What the access log says

The access log records what the server actually sent to every visitor, including the ones a kit would have filtered. In the common combined log format, field 9 is the status code and field 10 the response size. Compare the reported path with the homepage:

LOG=/path/to/example.com-access.log
grep -F 'GET /mygov' "$LOG" | awk '{print $9, $10}' | sort | uniq -c | sort -rn | head -20
grep -E '"GET / HTTP' "$LOG" | awk '{print $9, $10}' | sort | uniq -c | sort -rn | head -5
grep -E '"POST /mygov' "$LOG" | tail -20
  • If every request for /mygov got the same status and roughly the same size as GET /, the server served the homepage to everyone. That matches catch-all routing.
  • If some requests got a different size, or there are POST requests to that path or to a PHP file next to it, something else answered there. Treat it as a real incident.

Logs rotate, so also search the compressed older files, grouped by day. This is how you check the day the listing was made:

zgrep -hF 'GET /mygov' "$LOG"*.gz | awk '{print substr($4, 2, 11), $9, $10}' | sort | uniq -c | head -50

⏳ Step 5: The feed may have moved on

A blocklist entry records what someone saw at one moment. By the time the report reaches the site owner, the page may already be gone. The host may have removed it, the owner may have restored a backup, or the attacker may have deleted it to avoid attention. Check what the URL returns now:

curl -s -I -A "Mozilla/5.0" "$REPORTED" | head -15

A 404 or 410 today means the path is not served now. It does not mean it never was. The opposite is also true: a listing from months ago may come from a time when the domain belonged to someone else or pointed to another server. So read a listing as history, and decide based on three things together: what the URL returns today, what the logs show for the listing date, and what is on disk.

When you have concluded it was a catch-all false alarm, request a review through the feed's own form. Keep the evidence short and factual: the three status lines from Step 1, the similarity numbers from Step 2, the password-field result from Step 3, and the fact that the path does not exist on disk. When it was real and you have removed it, give the same evidence for the current state.

✅ Triage checklist

  • Fetch the reported URL, a random 16-hex path and the homepage, with and without following redirects.
  • Compare status, final URL, size and <title>. Same behavior for reported and random path means catch-all.
  • Compute 4-gram Jaccard similarity. ≥ 0.9 against the random path means "no separate page today".
  • For a bare-homepage report, compare against the random path, never against itself.
  • Count real <input type="password"> elements with an HTML parser. Ignore CSS, JavaScript and translation strings.
  • Check where every form posts: your own site, another host, or a PHP file next to the page.
  • Look for brand impersonation in title, headings, buttons and logos.
  • Repeat the fetch with mobile and desktop user agents and a referer.
  • On the server: does the path exist, what changed recently, are there kit or exfiltration patterns, which rule causes the catch-all.
  • In the access log: status and size for the reported path vs the homepage, any POSTs, the listing date in rotated logs.
  • Record what the URL returns today, and remember that a listing describes the past.

💡 Takeaways

  • A URL that loads is not a page that exists. Always test a random path next to the reported one.
  • Count form elements, not words. "Password" in a stylesheet is not a login form.
  • Real phishing pages differ from the homepage, ask for credentials and send them somewhere else.
  • Kits hide from analysts. When the public view is clean, the files on disk and the access log decide.
  • Returning a real 404 for unknown paths makes every future report easier to triage.

❓ FAQ

Why does a URL that does not exist on my site return HTTP 200?

Because your site uses catch-all routing. The theme, an SEO plugin, a single-page app or a server rule answers unknown paths with the homepage (a soft 404) or redirects them to it. The page you see is your homepage, not a page at that path.

The report says the page has a password field. Is it a login page?

Not necessarily. Stylesheets, JavaScript and translation strings mention "password" on almost every site. Only a real <input type="password"> element in the served HTML counts, and then you check whether the form posts to your own site or somewhere else.

The reported URL looks clean when I open it. Am I safe?

Not yet. Phishing kits often show their page only to some visitors, by country, device or referrer. Check the server: does the path exist on disk, which files changed recently, and what the access log shows for that path, including requests from the listing date.

The URL returns 404 now. Was the listing wrong?

Not necessarily. A listing records what was seen at one moment. The page may have been removed since. Use the rotated access logs for the listing date and the files on disk to find out what was actually served.

How do I stop catch-all routing from causing false alarms?

Return a real 404 for paths that do not exist. On WordPress, turn off any "redirect all 404s to the homepage" option. For single-page apps, send index.html only for routes the app knows. A real 404 makes every future report quick to check.