It’s the afternoon and I have refreshed the same GitHub page so many times that my finger has started to form opinions.

I have a lot of tabs open. Some are about the vulnerabilities. Some are about whether the vulnerabilities are real. One is a build log I stopped understanding a while ago. At some point I opened Hacker News “just to check” and came back to the room like someone leaving a casino.

The odd thing is that half the internet is doing the same. We’re all watching one pull request. It isn’t a status page or a dashboard. It’s a pull request in the repository for the official PHP Docker image, and a crowd of strangers is collectively willing it to go green.

I run engineering teams for a living. I’d love to say I spent the day calmly directing operations. In fact I spent it hitting refresh and saying “come on” to a CI matrix. This is the story of that day, and of the people who managed to get on with their jobs while the rest of us watched.

What actually happened

Some terms first. A CVE is a catalogue number for a publicly known security flaw, so everyone can discuss the same bug without describing it in prose. CVSS is a 0 to 10 severity score. Two bugs, CVE-2026-109618 and CVE-2026-109619, were each rated 9.2 on the CVSS v4.0 scale by the PHP security team. The nickname doing the rounds was “php2shell”.

The plan was orderly. Maintainers would coordinate a disclosure and ship patches, and everyone would get a fair chance to update. Everyone was supposed to wait until Thursday 22 October.

On Tuesday 20 October, at around 15:00 UTC, the two CVE IDs began circulating on online forums and social media. They came with a wrong release time and a wrong score of 10.0. The PHP Foundation says no technical details leaked. Reporting at the time also mentioned a Hacker News post that was taken down, while screenshots spread on social media.

In response, the PHP project brought its pre-announcement forward and published it at 19:30 UTC. It also moved the release from 22 October to Wednesday 21 October at 14:00 UTC (15:00 UK). The Foundation explains the thinking. Distributors were still packaging the fix, so releasing immediately would have left many users without an easy way to update. One day earlier was the compromise between moving quickly and giving people a simple update path.

Around 20:00 UTC, the Foundation says, one of the security firms that had reported the issues mistakenly published a video of their proof of concept working against a number of targets. It was deleted, but copies circulated, and the Foundation says the video contributed to accelerated development of various proofs of concept. Here is a post people can look at for themselves. I haven’t verified what it contains, so use your judgement before clicking.

Security firm watchTowr confirmed the vulnerabilities were real and reproduced one of them. They also noted, fairly, that everyone had been meant to wait.

On the morning of the release, the Foundation says, Chainguard published built images containing the fix at 07:41 UTC, more than six hours before the coordinated release. It describes this as breaking the embargo. I include it because it shaped the day, and I’m not going to say any more about it.

The Foundation says it didn’t identify any functional exploits at the time of release. A security vendor had likewise reported no in-the-wild exploitation in their fleet as of 20 October. I’m not going to speculate about how the IDs got out or why.

What the vulnerabilities are

I’ll stick to what has been officially published.

Remote code execution, or RCE, means someone who isn’t you can make your server run code of their choosing, from the other side of the internet. Security people hear those three words and sit up straight. What happens next depends on what the machine can reach. Sometimes that’s very little. Sometimes it’s a great deal.

These flaws are in PHP core, not a plugin or a single framework. The Foundation notes that both sit in parts of PHP that nearly every request touches: memory management and error handling. That central position is what made them serious, and hard to fix. In its words, PHP runs a large share of the web, including government services, online stores and banks.

The two bugs, as published:

  • CVE-2026-109618, RCE via out-of-memory (OOM) corruption. If a request hits PHP’s memory_limit at exactly the wrong moment, PHP can leave partially set-up internal data behind and later treat it as valid, corrupting memory. On Apache with mod_php, an unauthenticated request can trigger this before any application code runs, and full RCE was demonstrated with default settings. RCE was also confirmed on PHP-FPM through application-level code paths.
  • CVE-2026-109619, RCE via stale global state. A fatal error at the wrong point can leave internal state pointing at memory that belonged to a previous request. A later request handled by the same worker can then use that freed memory. A use-after-free and a worker crash were confirmed, and RCE was demonstrated against a real-world application on Apache with mod_php.

Put simply, PHP could be left holding a pointer to something that was no longer there, and be tricked into acting on it. The advisory says all PHP installations serving web requests are at risk, including PHP-FPM, mod_php, php-cgi, FrankenPHP and LiteSpeed, with the highest risk for mod_php.

The fixes are in PHP 8.5.12, 8.4.27, 8.3.36 and 8.2.35. The advisory says only an update is a complete solution. Any other measures reduce exposure to specific attack paths but don’t make an installation safe.

Now the point I’d most like you to take away. PHP 8.1 and older no longer receive updates from the PHP project. Given the severity, the security team did provide minimal source backports for 7.4, 8.0 and 8.1, and some distributions and LTS vendors backport fixes. But if you’re on an unsupported version, “update to the fixed release” isn’t available. You’re relying on a vendor, a source build or a migration project nobody scheduled. That’s arguably the nastier problem, because those systems tend to live where nobody’s looking.

The months-long backstory

This part deserves respect, and the Foundation tells it candidly in its own post.

According to the Foundation, the first signs of the OOM problem turned up in 2024, while a core developer was fixing an issue from PHP’s first external security audit in years. A potential exploit was theorised, but no concrete vectors were found and other issues with clear impact took priority.

Fixing it was hard. The security team developed several competing approaches, each with trade-offs: backward compatibility breaks, new denial-of-service potential, or changes to many third-party extensions that seemed impossible to coordinate. With no known path to RCE and a small team of engine experts stretched across many responsibilities, work on a fix, in the Foundation’s words, stalled and restarted repeatedly over months. It also says plainly that the delay was a structural failure and that the team is changing its processes.

That changed on 11 August, when a researcher at Calif reported an unconditional RCE with the same root cause. OpenAI independently reported the same root cause, and Wiz reported further attack vectors. From 11 August, the Foundation says, fixing it became the top priority, with people working through weekends and around the clock.

I’d call that an unglamorous problem handled by a small team, and that’s the point. These are people dealing with a hard design decision in a very old codebase, and they got there.

The waiting game

A fix existing and a fix being in your hands are different things, with a chain of dependencies in between.

The first link was the PHP fix itself. If you run PHP in containers, the next link was the official Docker image, which had to be rebuilt. That meant a pull request: docker-library/php#1694, authored by jnoordsij and approved by LaurentGoderre. I was following the situation through a public issue thread.

That pull request needed around 70 CI checks to pass. CI means continuous integration, the automated builds and tests that run before a change is accepted. Here there was one check for each architecture and variant the image is built for. Seventy small green ticks, any of which could turn red.

Then the internet arrived. A huge number of people descended on the pull request to comment, post memes and cheer the team on. I understand the impulse completely. I was one refresh away from joining in. But a pull request is a workplace, and this one suddenly had a stadium crowd at the door.

The maintainers locked the discussion to contributors only. Sensible. Then one of their CI actions failed because it couldn’t post a comment on the locked thread, and it had to be re-run. This isn’t a criticism. It’s what happens when a crowd lands on a system: the safeguard against the crowd trips over itself and someone presses the button again. A bot got locked out of the room it was meant to be commenting in.

Meanwhile GitHub started showing status failures and degraded performance as everyone rushed to get the fix out. A Node.js security release was due the same day, which added to the pile-on.

Through all of this, jnoordsij and LaurentGoderre kept their heads. They approved, they stayed steady and they got on with the job while a crowd piled into their pull request. They’re two of the heroes of the day, and neither wore a cape. They just kept shipping with the whole internet reading over their shoulders.

For my team, it meant our image build was delayed for hours. A separate package registry outage then hit the build too, which is the dependency-chain equivalent of queueing for a shop and finding it shut. We worked around it by pinning two extension installs to source tags. It’s not elegant, but it got us moving.

Information chaos

While waiting, I was bouncing between Twitter, Mastodon, Bluesky, Hacker News and infosec.exchange. I also read this write-up along the way.

If you’ve never watched a vulnerability unfold across five platforms at once, imagine five group chats, each with a different rumour, all faster than you can read. Theories and suggested stopgaps were proposed, tested and picked apart, sometimes within minutes. Someone would post a mitigation, someone else would say it didn’t cover everything and a third person would say it worked for them.

The Foundation says mitigation advice it started giving to a few critical infrastructure providers the night before may have leaked as well. I’m not suggesting any specific circulating stopgap came from that. I mention it because the pre-advisory advice floating about was a mix of official, secondhand and guesswork, and it was hard to tell which was which.

I’m not mocking anyone. Most people were trying to help, and some of it was useful. But my takeaway is firm: pre-advisory mitigations from social media are intel, not guidance.

  • They’re unverified. Nobody with authority has checked them.
  • They’re often based on guesses. Before the root cause is published, anyone proposing a fix is reasoning about a bug they can’t see.
  • They often cover only one path. A stopgap that blocks one way in can leave others open, which is worse than useless if it makes you feel safe.

The official advisory says the same: reducing exposure is not the same as being safe. Use the noise to learn what to watch for, and wait for the advisory before you declare victory.

What I’d tell other teams

Know where PHP is running, including the hidden places. Not just the main app. Think of the old admin tool, the marketing site and the thing a contractor set up years ago. You can’t patch what you can’t find.

Have a build and deploy path you’ve already proven. The worst time to find your pipeline is brittle is the day everyone needs it. Rehearse the boring path until it’s boring.

Avoid depending on a single upstream registry. One outage on top of an already busy day can add hours. Know your fallbacks before you need them.

Don’t claim “mitigated” while stopgaps are partial. A partial stopgap is a partial stopgap. Say “reduced exposure” if that’s what it is.

Pre-agree what you’ll do if a fix slips overnight. Who decides? What’s acceptable to leave in place until morning? Settle it over a calm coffee, not at 2am.

Plan for the unsupported. If you have PHP 8.1 or older anywhere, this is your reminder that “we’ll upgrade it eventually” has a cost, and it arrives without warning.

Close

To the PHP security team, to everyone who built, reviewed and approved the fix, and to jnoordsij and LaurentGoderre for holding the line while the internet leaned on the door: thank you. To the wider community who shared, tested and generally helped: thank you too, even if my refresh finger is still recovering.

Next time there’s a 70-check CI matrix and a crowd, I’ll resist the urge to refresh. I won’t succeed, but I’ll resist.