Graphic: "A PHP flaw leaked. AI may shrink your response window." over a canal at dusk, citing CVE-2026-109618 and CVE-2026-109619.

PHP2Shell Is an Inventory Emergency Before It Is a Patching Emergency

PHP announced two critical vulnerabilities, CVE-2026-109618 and CVE-2026-109619, and the internet reacted the way it always does. Teams scrambled for patches. Government websites in Europe went offline entirely. PHP powers roughly 70% of websites, so the exposure is structural, reaching back to version 5.4.

Here is what I kept noticing while working through the advisories. The patch was never the hard part. The hard part is knowing where PHP actually runs in your estate.

The speed of your response gets set long before the advisory lands. It gets set by how well you mapped what you run.

The Runtime Lives Underneath Your Application

Updating WordPress or its plugins does not update PHP. These are separate components with separate lifecycles and, in many organisations, separate owners. A clean application dependency scan proves nothing about the runtime underneath it.

This distinction matters more than usual here. With these flaws, PHP processes the malicious request before any application code runs. Your login screens and security plugins never wake up. Application-level controls sit above the layer being attacked, so they contribute nothing to your defence.

In practice, PHP runtimes exist in a fragmented state: PHP-FPM, CGI, Apache mod_php, containers, control panels, appliances, managed hosting and forgotten sites. Each one is a component with its own version, exposure and update path. Treat them as one monolith and your inventory lies to you.

The Response Window Has Collapsed

Sansec's forensics team expects mass attacks within 15 minutes of a patch release, because attackers reverse-engineer fixes by comparing old and new code. When CVE-2024-4577 became public in 2024, exploit attempts hit honeypots within 24 hours.

AI tightens this further. There is no evidence that AI created or discovered these CVEs. But research shows that once a CVE description exists, LLM-assisted exploit generation becomes dramatically cheaper and faster. Work that took a skilled engineer days now takes a motivated attacker a capable model and API costs measured in tens of dollars.

If attackers move in minutes and your inventory takes days to assemble, the race is already lost. One study found only 28% of companies believed their asset inventory was accurate. That number should worry any technical leader more than the CVE itself.

The Sequence I Recommend

I highly recommend you work through this in order, because each step depends on the one before it.

  1. Inventory every PHP runtime. PHP-FPM, CGI, Apache modules, containers, appliances, cPanel and Plesk, managed hosting and forgotten sites. Record the exact version, branch, deployment source, exposure, named owner and update path.
  2. Prioritise internet-facing and end-of-life systems. The PHP project is releasing no fixes for 8.1 or earlier. Anything on an end-of-life branch gets no vendor patch, ever. Those installations need migration or isolation, and they need it first.
  3. Apply the official fix or a verified vendor backport. Verify against the official PHP advisory and your distribution or hosting provider before trusting any version claim, including the ones circulating in early reporting.
  4. If patching must wait, deploy temporary containment. Narrow access restrictions, edge filtering, origin protection or isolation. Test the impact and document the limits. Containment buys time. Recording it as a resolution in your tracker creates a false sense of completion that will cost you later. Maintenance mode does not guarantee PHP stops processing requests.
  5. Investigate after patching. Preserve logs. Check for unexpected files, web shells, spawned interpreters, persistence mechanisms, new accounts and unusual outbound traffic. A patched server was still exposed before the patch landed.
  6. Keep unverified public proof-of-concept code away from production. AI can help you enumerate assets, draft queries and compare advisories. A named human owner must verify every generated command and change before it executes. Unreviewed automation imports fresh uncertainty into a moment that already has plenty.

Every Runtime Needs a Named Owner

The 2026 disclosure carries a sobering detail. A researcher flagged the first signs of one flaw back in 2024, but the issue was theorised without concrete vectors and other concerns overshadowed it. The PHP Foundation itself called the delay a structural failure. Even the people who maintain the language struggled with ownership and prioritisation.

That tells me the lesson applies at every scale. For each runtime in your estate, record three things: a named owner, evidence of a verified fix or documented temporary containment, and a post-patch compromise review. Treat the inventory as continuous work rather than an annual exercise, because the next advisory will arrive on its own schedule.

Systems are never done. They are stable enough to improve upon. The same holds for the map of what you run.

When the next emergency lands, will your team spend the first 48 hours patching, or searching for what needs patching?