Services · Critical vulnerabilities

Critical PHP vulnerabilities, handled as a workflow

Everyone writes about the exploit. Far fewer explain how to handle one, step by step, in the hours before the details are out. This is the workflow we follow, and how it went on PHP2Shell in October 2026: our build was live within seven minutes of the release, our end-of-life applications within thirty, and nothing hit us.

The hours before the details are out

A critical vulnerability rarely arrives as a patch. It arrives as a warning: a post, an advance notice, a date. There is no fix to install and nothing concrete to test against, and the tempting choices are to wait or to panic. Both waste the most useful hours you will get.

What helps is deciding the order in advance, so that on the night itself people carry out decisions instead of making them.

How we handle it

  • Check the claim before acting on it. An AI model reads the source of the affected version against the claim and tells us whether the path is plausible. Reading, not exploiting: the goal is to know where to act, not to build an attack.
  • Close the worst path first. If we have to choose, code execution comes before availability. A configuration change that removes the exposed feature, with every worker restarted, beats a complete fix that arrives tomorrow.
  • Have the switches ready before you need them: a maintenance page that can take all traffic off in one click, and a firewall rule at the edge that blocks the risky requests. Both ready, both off.
  • Build early. Vendors sometimes update their images with the fix shortly before the announcement; this time it was about twenty minutes. We start the build from those and verify it against the official release the moment it is published.
  • Watch the traffic once the details are public, with an agent armed with actions decided in advance: ban the address, flip the switches, restart the service, in seconds.
  • Do not forget the old versions. Applications past end of life get no official release, so the fix is backported from the official sources, compared with community backports where they exist, and tested before it ships.

AI does the reading, the backporting and the watching at a speed a small team could not match on its own. People decide the order, and they decide it before the details are out.

PHP2Shell, 20 and 21 October 2026

On 20 October a post claimed that two critical remote code execution flaws in PHP were about to go public. No patch, no details, only a claim about session uploads. We asked Claude (Opus 5.5) to read the PHP source against the latest version. It did not reproduce an attack, but it traced the path through the code and showed the claim could be real.

That was enough to act on. We switched off session upload progress and restarted every worker, on every cluster and machine. We readied a maintenance page for all traffic and an edge rule that blocks every upload, both off.

About twenty minutes before the official release, vendors updated their images with the fix, so our build was already running when PHP published the fixes on 21 October at 14:00 UTC. There were two flaws, not one: CVE-2026-109619, stale state reached through session upload progress, and CVE-2026-109618, memory corruption after running out of memory, which we had not seen coming. We applied the interim memory setting from the advisory, put an agent on the live traffic, and had the verified build live within seven minutes of the release.

The end-of-life applications had no official release coming. An agent backported the fix from the official sources while community packages shipped backports of their own. Comparing the two, it found one part missing from the package for our version, with a note saying the code was already there. It could not find that code, so it merged both. The tests passed, and thirty minutes after the release the old applications were patched too. Nothing hit us.

AI on both sides

The researchers who found PHP2Shell, at Wiz, Calif and OpenAI, used AI models to find the bugs and turn them into working exploits. That is the pace now. The defending side needs the same speed, with the same discipline about who decides what.

How it is scoped

On a monthly retainer, critical vulnerability response is part of the work, with what counts as an incident and how quickly it is picked up agreed in writing. Getting ready for the next one (the switches, the build pipeline, the list of end-of-life versions still running) fits a security assessment and hardening of one to three weeks. Scope and price come in writing after a 20-minute conversation.

Critical vulnerabilities

Questions

Do you patch before the official release?

We act before it: a configuration change that closes the known path, switches ready, a build started from vendor images. The fix itself goes live once it is verified against the official release.

Can you patch PHP versions past end of life?

Yes. There is no official release for them, so we backport the fix from the official sources, compare it with community backports where they exist, and run the tests before it ships. The lasting answer is still an upgrade, and we can plan that too.

Does the AI act on its own?

Within limits set in advance. It reads source code, writes backports and watches traffic. The actions it may take by itself, such as banning an address or flipping a prepared switch, are decided by people before the night, and what it writes is tested before it ships.

How do we get ready before the next one?

Know which PHP versions you run, including the old ones, prepare the switches and the build pipeline, and agree who decides what. A security assessment of one to three weeks covers it, and the retainer keeps it current.

Contact

Let's talk

Tell us what you have, in your own words. You do not need to know which technology the system runs on; we will work that out. You get back questions and a written proposal.

Write to usor directly at [email protected]