┌─ PHILE #01 ─────────────────────────────────────────────
date: 2026-11-19 tags: security · honeypot · php2shell · golang · runreveal · reveald read: 7 min
└────────────────────────────────────────────────────────────────────

I put a fake PHP website online. Here's what scanners are trying

After the PHP2Shell outburst and craze, I felt like I found the perfect excuse to finally lay my hands on a couple of tools while conducting some research/investigation work on top of that:

  • RunReveal’s reveald
  • A topic of interest
  • An excuse to handwrite code

The first application, reveald, is a shameless self-plug because I work for the company that built it. It’s a log forwarder natively integrated with RunReveal and we use it a lot to help people safely forward logs from the wildest locations to the platform. And I wanted some hands-on experience with it.

This post goes through this short 3-week experiment around the PHP2Shell vulnerability, content scanners and scrapers.


Background Story

The server

While I do like AI as a tool and think there’s a place for it in the world, I often miss writing code myself. The idea of getting into deep focus, spend hours writing code, headphones on, fully-immersed, it’s awesome and I miss it dearly.

When this idea came up, I thought about spinning up an existing honeypot dedicated to this specific vulnerability. But if I can find those, so can bad actors and their scanners. I feel that if you’re looking to run a honeypot for real, you should not run publicly available stuff. It’s good to get some ideas and inspiration, but I would not use it for a real investigation because real bots and scanners can also those public repositories and build logic to skip them once detected. I felt complled to write my own honeypot. For the fun.

I wrote my own Go fake PHP server. I used Go because, well, not only I like it, but packaging and deploying applications is a breeze, dependency-free, no BS. And it’s very low footprint.

You can see the source code for it here: https://github.com/gsilvapt/phphoney

It is the most boring honeypot of all times. And that was the goal: Keep it simple, track HTTP requests that hit the server and also some other ports, like SSH.

It returns the default Apache page (lol), some hammered response headers one would typically see in a real PHP service, and some other forced references to make it seem like this was actually running behind a Ubuntu, Apache, PHP server to deceive scanners, scrapers and bots-alike (and hopefully agents and AI-assisted tools).

Deployment

After having a working server, the next step would be to decide how to make it securely available on the internet. It is a disposable concept, but still don’t want to get pwned - and not break the bank (compute is very expensive these days. Thanks AI!).

I decided to go with the lowest-spec, cheapest Hetzner option. I figured reverse proxying this service using Caddy would make a lot of the setup work just easy and I was already containerizing the application.

The last piece of the puzzle is Cloudflare. Free tier is more than enough for this stuff and you get DNS sorted for you.

The only downside (upside, actually?) is that their free tier has all managed rules on and you can’t disable them. This means some traffic will get dropped automatically due to their managed rules, as we’ll discuss later in the post.

reveald

As mentioned before, I work for RunReveal and one solution we develop and maintain is reveald: https://docs.runreveal.com/sources/forwarders#reveald

With a single configuration file - you can see mine in the repo, under deploy/reveald.json, I was able to ship the container’s logs effortlessly. Some additional tweaks in the file format and any agent would be capable to figure out the log structure and what to look into, specially when paired with the source code.

Cloudflare

In a previous section we mentioned the downside (upside?) of using Cloudflare - the fact they have their managed rules enabled on free tier and users not being able to disable them.

While Cloudflare in itself is not a critical part of this investigation, it’s worth noting their rules blocked ~7% of the requests. I’m pretty sure these are some php2shell-like payloads and their WAF is doing their thing to block this stuff.

Cloudflare Dashboard view showing requests blocked on their end

Cloudflare Dash

This also means, whatever reveald pushed to the SIEM successfully bypassed their WAF! Not sure if this means it’s because it is a harmless payload, or their rules need adjustments.

Initial Assessment

At this point, server is up and publicly exposed. But I have a healthy degree of paranoia about these things.

Once I could see some HTTP server and the host’s logs, I decided to use the RunReveal MCP to pull some logs and write some detections (core platform feature) for me, to make sure I get some signals about what’s happening, but also I get notified if I truly, somehow, get pwned.

It’s interesting how fast these things are able to process large amounts of data, discover patterns, understand the data schemas and come up with reasonable detections.

RunReveal Honeypot Detections view

RunReveal Honeypot Detections

The agent felt relevant to include other detections happening on the Linux host, which I agreed too just in case. I knew if these detections found something, I’d be in trouble.

Anyway, this was the initial footprint of stuff. Nothing interesting, I was hoping to get some funnier results later on.

In the first 10 minutes I saw a burst of content-discovery bots looking for things like .env, .git/config and similar.

As we’ll discuss in the findings section, this was what predominantly hit the server.

Findings

Credential Harvesting is now looking for LLM stuff

SSH was intentionally open as well, not only to allow me to login remotely, but also to see what type of things scanners are currently trying (more on that later).

From the time window of 2026-11-05 21:48Z → 2026-11-06 09:47Z, the service got a total of 23 thousand requests, 96% of which were to the SSH service and the remaining 4 to the HTTP service.

The HTTP honeypot breakdown is as follows: Methods: GET 741, HEAD 2, POST 1. Effectively a GET-only scan pattern.

CountryReqsNotes
TH33144% of all HTTP. Methodical .env sweep behind a spoofed Chrome UA
US32.env / .git/config hunter, spoofed Firefox
NL25leakix (l9scan)
US25leakix (l9scan)
PL24.git/.svn/.hg VCS exposure sweep
US21ClaudeBot (legit crawler)

The .env sweep is very much what you can think of and every other variant (.bak, .prod, .staging, .swp, .env, plus path-prefixed credential targets including /smtp, /mailgun, /wordpress, /magento, /app and the list goes on).

I witnessed some paths focus on version control too, like .git/config or svn stuff, and some attempts to detect known frameworks the website could be running - /@vite/env, /telescope/requests (laravel), /wp-login.php, /?rest_route=/wp/v2/users/ and more.

As I mentioned before, the SSH hot-path surfaced an interesting takeaway on the state of credential harvesting bots. Here is the list of most tried usernames, and I’m most interested in the last two:

  1. ubuntu (236)
  2. admin (125)
  3. user (90)
  4. deploy (69)
  5. test (57)
  6. claude (30)
  7. openclaw (20).

As these tools become popular and lots of people are running them on the internet, and the fact there is a number of projects to lower the barrier to run your own agent, it shouldn’t be surprising to see AI-theme names in content-discovery. While the security defaults should be better protected, I would not be surprised if these scanners occasionally find these for real out there.

Bots got fooled

Whether AI-assisted, humans or plain scripts, I have reasons to believe the fake server worked well to trick them to try php2shell payloads. I saw a few requests containing payloads resembling the php2shell vulnerability.

One single actor ran 41 requests (31 GETs + 10 POSTs) against the honeypot, in one 26-second burst (which suggests automation). These requests had a minor level of spoofing (user-agents mostly).

These alude to an automated PHP LFI→RCE scanner using a p2s (“php2shell”) execution oracle. Every payload carries a canary ___P2S_RCE_OK_<id> that echoes sha256(canary|p2s) — the tool knows it got code execution only if that exact hash comes back. Two canary IDs were used: 004714 and b9e366. Obviously nothing came back because we are not executing any PHP under the hood.

The three techniques that stood out are:

1POST /index.php?page=php://filter/convert.iconv.UTF8.CSISO2022KR|convert.base64-encode|convert.iconv.UTF8.UTF7|convert.iconv…/resource=php://temp
2    body: 0=echo '___P2S_RCE_OK_b9e366'.substr(hash('sha256','___P2S_RCE_OK_b9e366|p2s'),0,16);echo '…_END';   (URL-encoded)
1POST /index.php?file=php://input
2<?php echo '___P2S_RCE_OK_004714'.substr(hash('sha256','___P2S_RCE_OK_004714|p2s'),0,16);echo '…_END';?>
  1. GET /?page=data://text/plain;base64,PD9waHAgZWNobyAnX19fUDJTX1JDRV9PS18wMDQ3MTQn…

Knowing how some of these firewall rules often work, I suspect this is how these actors are now testing for p2s. A harmless request that will not trigger any rules looking for access to sensitive files and, if they succeed, pretty sure they will send their heavy guns at the service.

The deception caused by the the service also made sure we captured a lot of PHP-specific paths. I’m convinced some of those readers and paths forced a script to enter it’s PHP specific things. Hence, I have a bunch of logs like GET /index.php?file=php://filter/read=convert.base64-encode/resource=/etc/passwd, or /wp-content/plugins/.

Closing thoughts

I was honestly expecting a bit more traffic hitting the service, but my very conservative approach probably didn’t help. Nor the time this was up and running (3 weeks in total?). I suspect to get better results having some form of interaction would help - like faking successful responses that would make these bots think they were onto something.

As expected, there are a lot of automated infrastructure looking for low-hanging fruits out there. Surprisingly, mostly seem to use the main cloud providers infrastructure (AWS, GCP, Azure) - and I say surprisingly because those are expensive. But perhaps it’s well worth it considering the scale these low-effort low-hanging fruit looking things operate and how this things usually unfold.

While I cannot provide any major breakthrough about the php2shell or the easiness to exploit it.