PHP2Shell and the Basics We Keep Skipping, A Security Reflection
PHP2Shell and the Basics We Keep Skipping, A Security Reflection

The Bug That Waited Fourteen Years: What PHP2Shell Made Me Admit About Our Industry

I’ve been turning last week over in my mind since the PHP2Shell news broke, and I keep landing on an uncomfortable thought: the most important security story of the year isn’t really about a vulnerability. It’s about us.

For anyone who missed it, two critical flaws in PHP were disclosed on October 21. CVE-2026-109618 and CVE-2026-109619, both scored 9.2 out of 10, both allowing an unauthenticated attacker to run their own code on a vulnerable server. No password. No login. Just a crafted request and a way in. PHP sits underneath roughly 70% of the websites on the internet, so when I say “a vulnerable server,” I mean a very large share of the machines that hold up the digital world.

The headlines focused on the drama, and there was plenty of it. Exploitation attempts were spotted four days before the patches even shipped. Government portals and e-commerce sites took themselves offline within hours of disclosure. Archive.org went dark. The NSA, CERT-EU, and the UK NCSC all issued urgent warnings. Within days, researchers confirmed working shells landing on honeypot servers, and CISA added both flaws to its Known Exploited Vulnerabilities catalog.

But drama fades. What stays with me are two quieter lessons, and they’re the ones I think we’ll still be talking about years from now.

If PHP2Shell has you thinking more seriously about your own security posture, start a conversation with Munyaka.ai. No pitch, just a discussion about what this moment means for organizations like yours.

Lesson One: We Already Know What to Do. We Just Don’t Do It.

Lesson One: We Already Know What to Do. We Just Don’t Do It.
Lesson One: We Already Know What to Do. We Just Don’t Do It.

Here’s the detail that stopped me cold. The vulnerable code dates back to PHP 5.4, released in 2012. These bugs sat in plain sight for fourteen years, inside software that most of the web depends on. A PHP core developer actually ran across the underlying out-of-memory issue during an audit back in 2024. The team looked at it, couldn’t agree on a fix, concluded that a practical exploit wasn’t feasible, and set it aside.

I don’t say that to criticize the PHP maintainers, who do heroic, largely thankless work. I say it because that moment, the “we’ll come back to it later” moment, is one I recognize in almost every organization I’ve ever worked with.

The evidence is in the numbers. When the patches arrived, they only covered supported branches, PHP 8.2 through 8.5. Yet internet-wide observation data showed only about a third of identifiable PHP instances were running those branches. The single most common version in the wild? PHP 7.4, which has been end of life for years and will never receive this fix. Two thirds of the observable PHP world was running software its own maintainers had already stopped supporting before this crisis even began.

This is the pattern I see again and again in security. The failures that hurt us most rarely come from some exotic, unknowable threat. They come from fundamentals we already understand and keep deferring: running supported versions, applying patches promptly, knowing what software we actually have and where it lives. We treat these as housekeeping, something to get to after the “real work.” Then a week like last week arrives, and suddenly the housekeeping is the only thing that matters.

The uncomfortable truth is that for a huge number of organizations, the difference between safety and exposure last week had nothing to do with sophisticated defenses. It came down to a single, boring question: were you on a supported version, or weren’t you?

If any of this resonates, whether it’s the version drift, the deferred patches, or the systems nobody remembers deploying, reach out and start a conversation. We’re happy to talk it through.

Lesson Two: The Clock Has Changed, Permanently

Lesson Two: The Clock Has Changed, Permanently
Lesson Two: The Clock Has Changed, Permanently

The second lesson is the one I think most commentary has underplayed. PHP2Shell wasn’t just found. It was found by AI.

One of the flaws was uncovered with the help of OpenAI’s GPT-5.6 Sol, during an audit of PHP’s source code, as part of OpenAI’s “Patch the Planet” initiative. Wiz independently found the same issues using frontier models including Google’s Gemini 4 Argon alongside GPT-5.6 Sol. And here’s the part that should recalibrate how every leader thinks about security timelines: according to Wiz, AI helped turn vulnerabilities that had lurked in the codebase for over a decade into something a single researcher could exploit in about a week. Their estimate for the same work done the old way? Months, with a world-class team.

Read that again. Months, compressed into days. That is not an incremental improvement. It’s a phase change.

And it cuts both ways. This time, the defenders found the bug first, and we should be grateful they did. But the same capability that helps a researcher audit decades-old code helps an attacker reverse-engineer a patch, map target environments, and generate exploit variations. All the slow, tedious work that used to buy organizations time after a disclosure can now be automated in minutes. Some analysts described the time-to-exploit for PHP2Shell as effectively negative, with attack attempts detected before the official disclosure even happened, and working proof-of-concept code circulating within minutes of the patch release once attackers diffed what had changed.

Meanwhile, the raw volume keeps climbing. More than 72,800 CVEs were published between January and September of this year alone, up 106% over the same period in 2025. AI didn’t create all of that growth, but PHP2Shell is a preview of what happens as these models get better at auditing the mountains of legacy code the modern world runs on. More flaws will surface. They’ll surface faster. And the window between “patch available” and “attack underway” will keep shrinking toward zero.

I’ve started thinking of it this way: we have moved into an era of permanent urgency. There is no quiet season coming. The race to find and fix before someone else exploits isn’t an occasional sprint anymore. It’s the pace of the game itself.

If you’d like to think out loud about how AI is changing the security timeline for your organization, contact Munyaka.ai and let’s have that conversation.

Where Those Two Lessons Meet

What strikes me is how these two threads depend on each other.

If AI has permanently compressed the timeline, then the old excuse, “we’ll patch it in the next maintenance window,” stops being a risk decision and becomes a gamble with terrible odds. You cannot respond to a threat that moves in days with a process that moves in months. And you cannot patch what you don’t know you have. Remember, PHP hides inside appliances, monitoring tools, admin consoles, and vendor products far beyond your main website. The organizations that scrambled hardest last week weren’t the ones with weak security teams. They were the ones discovering, in real time, how little visibility they had into their own environments.

Which brings me back to the basics, but with new weight on them. In an AI-accelerated world, fundamentals aren’t the floor of your security program. They’re your speed. A current asset inventory is what lets you answer “are we affected?” in hours instead of weeks. Running supported versions is what makes a patch available to you at all. Practiced patching and response processes are what let you move at the pace the threat now demands. The organizations that handled last week well didn’t have magic. They had discipline, built quietly, long before anyone had heard of PHP2Shell.

There’s also a question in all of this that I don’t think we should dodge: if AI can find these flaws, are we using it to find ours first? Red teaming, threat modeling, adversarial testing of the systems we build and deploy, these stop being optional extras when the other side of the fence has access to the same accelerating capability. The honest answer for most organizations is no, not yet. That gap won’t stay survivable for long.

If you’d rather talk through your situation with someone who’s seen this pattern before, start a conversation with us and we’ll take it from there.

Where Those Two Lessons Meet
Where Those Two Lessons Meet

A Final Thought

Last week could have been catastrophic, and in many ways we got lucky. The good guys found it first, the maintainers responded well, and the exploitation we’ve confirmed so far has been limited compared to the exposure. Luck, though, is not a strategy, and it certainly isn’t one I’d want to defend to a board.

So here is what I’m sitting with. The next PHP2Shell is already out there, sitting in some aging codebase, invisible to us and increasingly visible to machines. When it surfaces, the winners won’t be the organizations with the biggest budgets. They’ll be the ones who treated the boring fundamentals as urgent before they had to, and who learned to use the same accelerating technology to defend themselves that others will use to attack.

This is exactly the kind of moment we built Munyaka.ai for. Not to sell fear, but to help organizations do the unglamorous work well: knowing what they run, closing the gap on unsupported systems, pressure-testing their AI and infrastructure before someone else does, and building response processes that match the speed the threat now moves at. If last week left you unsure where you stand, that’s a solvable problem, and it’s one we’re glad to help you solve.

The bug waited fourteen years. The next one won’t wait for us to be ready.

If you’d like to connect directly and talk through what PHP2Shell means for your organization, you can reach David on LinkedIn or contact us here. We’re glad to listen first.