PHP2Shell, Cl0p, and a playbook that hasn’t really changed in five years. Except for the one part that matters.
Let’s start with a criminal gang, not a CVE.
December 2020. Cl0p gets into Accellion’s file transfer appliance through a flaw nobody else knew about. Around a hundred companies lose data. Two years later, January 2023, same gang, different file transfer product. GoAnywhere this time. Then MOVEit in May 2023, over the US Memorial Day weekend, and that one hit more than 2,500 organisations. Then Cleo at the end of 2024. Then Oracle E-Business Suite in 2025.
Five products. Same crew. Same kind of target, the software that sits on the internet holding other people’s files. Same move every time: get in before the vendor even knows there’s a problem, take the data, send the ransom emails later.
If you’re the vendor, each one of these feels like a bolt from the blue. Step back a bit and it looks more like a calendar.
Cl0p is just the neatest example. Zoom out and you’ll find the same sequence in pretty much every big one of the last five years.
The playbook
It goes roughly like this. Not always in this exact order, but close enough.
The bug is in something shared. A runtime, a library, an appliance. Not your code. Something your code sits on top of.
Someone is already using it before the patch. Sometimes before anybody has even said publicly that there’s a bug.
The moment it goes public, the whole internet gets scanned. Within hours, not days.
Defenders lose the first few days just finding where the thing runs. Patching comes later. Much later, in some cases.
A long tail stays open for years. And some of the boxes marked as patched were already owned before the fix went on.
Here’s how that looks against the big ones.
| Incident | Where the bug lived | Used before the fix? | What was left behind |
|---|---|---|---|
| Log4Shell, Dec 2021 | Java logging library, buried inside other software | Yes. About a week before it went public | Around 13% of Log4j downloads in 2025 still vulnerable |
| MOVEit, May 2023 | File transfer product | Yes. Zero-day, over a holiday weekend | 2,500+ organisations hit |
| Citrix Bleed, Oct 2023 | VPN / gateway appliance | Yes. Since late August | Stolen sessions kept working after the patch |
| Ivanti, Jan 2024 | VPN appliance | Yes. Since December 2023 | CISA told agencies to unplug the boxes |
| PHP2Shell, Oct 2026 | PHP runtime | Yes. 4 days before the patch | ~884k hosts on PHP 8.1 or older, lots with no fix at all |
Just read down the middle column. Yes, yes, yes, yes, yes. That’s the whole argument.
So when people call PHP2Shell a wake-up call, I’d push back a little. The alarm’s been ringing since 2020. This is the same attack we’ve been watching for half a decade. New name, new CVE number, same plot.
And that’s actually good news, because a playbook that repeats is a playbook you can plan for.
So why does it still keep working?
This is where I have to argue against my own headline a bit.
If the steps are the same, you’d think by now we’d have them beaten. We don’t. And the reason is that the one thing which did change is the exact thing our processes are built around. The clock.
1. The clock flipped
For years the conversation was about the patch gap. Vendor ships a fix, attackers reverse it, you have some days before they show up. Mandiant has been tracking that number for a while. 63 days in 2018-19. Then 44. Then 32. In 2023, five.
For 2025, their estimate is minus seven. Meaning on average, exploitation is starting a week before there’s a patch to apply.
Most patch SLAs I’ve seen, 30 days for criticals, maybe 7 if the team is strict, were written for the left side of that chart. They’re still on the books. The chart moved.
2. Bugs are found in bulk now
In 2021 a bug like Log4Shell was basically one researcher’s secret until disclosure day. That’s not the world anymore.
PHP2Shell was found on 19 August 2026 by Wiz, using AI-assisted tools. It then sat in coordinated disclosure for about 63 days. Somewhere in that window it leaked. Amazon’s honeypot saw an exploit attempt on 17 Oct, four days before the patch, and Amazon said they don’t know how the attacker got the details.
Multiply that by a lot. Partners in Anthropic’s Project Glasswing reported around 129,000 verified vulnerabilities between April and July this year alone. By early October, of the roughly 6,000 open-source ones that were disclosed, about 8% had been patched upstream. Finding bugs got cheap. Fixing them didn’t. Maintainers are still people.
So there’s a queue now. A long one. And it isn’t as private as it looks, because if one team with a decent model can find a bug, another team with a similar model can find the same bug the same week. Not all of them file a report. Linus Torvalds said it pretty bluntly: AI-found bugs are “pretty much by definition not secret”. The embargo period used to be the safe bit. Now it’s the exposed bit.
3. The front door moved to the edge
The targets haven’t changed in kind, but the mix has shifted a lot. In Verizon’s 2025 breach data, edge devices and VPNs went from 3% to 22% of breaches that started with an exploited vulnerability, in one year. For those edge bugs, mass exploitation started on day zero. Google counted a record 48 percent of 2025 zero-days in enterprise products, about half of them security and networking kit. Basically the stuff that’s supposed to protect you.
One honest caveat
It’s tempting to make this a sky-is-falling story. It’s not really that. Only about 1.4% of published CVEs ever get exploited, and AI-found ones get exploited at roughly the same rate as everything else. The share of exploited bugs hit before disclosure day actually dipped a little in the first half of 2026. 2026 is heading to something like 66,000 CVEs total.
So it’s less a wave and more a flood with a few sharks in it. The few that matter are turning up earlier. Everything else is noise you still have to wade through.
Which kind of changes the question. It’s no longer “how fast can we patch?”. You can’t patch 66,000 things fast. It’s more like: on the morning something leaks, can we say which of our boxes actually have the problem, with proof, before there’s even a fix?
Same playbook, so plan for it
Not a big transformation programme. Just a handful of decisions you make before the next one, instead of during it.
Start the clock at the first signal. A leaked CVE ID, a vendor saying an emergency release is coming, a credible exploit report. Not patch day. Definitely not the day it lands in CISA KEV, by then you’re a week late, minimum.
Know your internet-facing estate before you need to. And know it at the runtime level, not the app level. “Which apps do we have” is easy. “Which hosts are serving PHP 8.1” usually gets you a long silence. Discovery on the day of the leak is a scramble. Discovery that was already running last week is just a filter.
Don’t trust version checks. After PHP2Shell we looked at more than a million assets. 65% of the organisations had at least one exposed application. A simple version-header check, which is what most teams ran on day one, missed 48% of real exposures and wrongly flagged roughly one in four of the rest. Hardened servers hide versions, backported packages keep old version strings, catch-all routes say 200 to everything. You need to actually validate.
End-of-life is its own problem. PHP shipped fixes for 8.2 to 8.5. Older branches got source patches or nothing. Hosts with no fix shouldn’t sit in a patch queue forever. Give them an owner and a decision. Isolate, migrate, or retire.
Patched isn’t the same as fixed. With PHP, the old code stays in memory until every worker is restarted, master process included. Auto-updates install the package and leave the old binary running. And Citrix Bleed already taught us the attacker may be in before the patch goes on, so hunt while you patch, not after.
Where FireCompass fits
This is pretty much what we built the platform for, so I’ll keep it short. FireCompass keeps a running outside-in view of your internet-facing assets, including the subdomains and staging boxes and forgotten admin panels that tend to fall out of the CMDB. When something like PHP2Shell drops, a day-one check goes out across all of it. For PHP2Shell, ours was live within a day of disclosure and ran across 1M+ assets, using a handful of normal requests per app.
Where that check comes back as “not sure”, our AI pentest agents go and confirm it, under scoped authorisation, and show what an attacker could actually reach from that box. That’s how the hidden 48% got confirmed instead of reported as maybe. After the fix, we rescan and check it’s actually live, restart included, so the evidence is there for the auditor too.
The next one
Cl0p will be back. Probably another file transfer product, probably over a long weekend. Someone will find the next PHP2Shell with a model, and it’ll sit in somebody’s disclosure queue for a couple of months, and maybe it leaks and maybe it doesn’t.
None of that is new. We’ve watched it for five years.
The only real question is whether your clock starts when theirs does. Or a week later, when the patch shows up.
Run a free AI pen test on one of your applications →
Sources
Mandiant, Time-to-Exploit Trends 2023; Google Cloud, M-Trends 2026.
Google Threat Intelligence Group, 2025 Zero-Day Review.
Verizon 2025 DBIR (via GreyNoise summary).
VulnCheck, State of Exploitation 1H 2026.
Cloud Security Alliance, AI vulnerability disclosure bottleneck paper, Nov 2026.
Recorded Future PHP2Shell timeline; The Hacker News / BleepingComputer on Amazon MadPot, Oct 2026.
Public reporting on Cl0p campaigns: Accellion (2020-21), GoAnywhere, MOVEit (2023), Cleo (2024), Oracle EBS (2025).
FireCompass PHP2Shell Exposure Research, October 2026.
