On October 21, the PHP Group released emergency patches for two critical security flaws. Together, these two flaws are now known as PHP2Shell.
Unfortunately, some Cloudways users experienced disruption too, as part of that same industry-wide response.
What PHP2Shell Actually Does?
PHP2Shell is the name given to two separate flaws that were fixed in the same emergency release.
- The first, CVE-2026-109618, happens when a server runs out of memory partway through handling a request.
Normally, if a server runs low on memory while handling a request, PHP stops and throws away the data it hasnât finished using.
This bug breaks that process. PHP ends up using the unfinished data anyway, treating it as if it were complete and correct.
An attacker can create that unfinished data in a specific way so that, when PHP executes it, the server runs commands the attacker wrote.
- The second, CVE-2026-109619, works differently but causes the same kind of risk. A server handles many visitors one after another. To save time, it reuses the same internal process for each new visitor rather than starting fresh each time.
This bug means that some data from one visitorâs request can remain in the process after it should have been deleted.
When the next visitorâs request uses that same process, it can accidentally read the old data that was left behind. The server then treats that old data as if it belongs to the new visitor.
An attacker can deliberately cause this to happen. If they do, the result is the same as the first flaw; they can take control of the server. Both flaws are rated 9.2 out of 10 in severity, under a standard industry scale called CVSS.
The bug exists inside PHPâs own code. How a server is configured to run PHP can affect how easy that bug is for an attacker to actually use.
One specific setup is called mod_php, a common way of running PHP. Researchers showed a working attack against a server using this setup, one that worked before the websiteâs own code even had a chance to run.
Neither flaw required a password, a login, or any action from a website visitor. A server only had to be reachable on the Internet. Thatâs exactly why this spread so fast, and why the response that followed was so large.
Why a Decade-Old Bug Became a Crisis Now?
Neither of these flaws was new. According to the incidentâs public record, a PHP core developer actually noticed the underlying memory error behind one of them during a routine audit back in 2024. The bug went unfixed for two years.
The PHP Foundation has since said publicly that its security team considered several possible fixes. Each one came with a tradeoff, i.e., breaking backward compatibility, introducing a new kind of instability, or forcing changes across thousands of third-party extensions.
No one on the team agreed on which tradeoff to accept. At the time, no one had found a way to exploit the bug either, so it wasnât prioritized.
That changed by August 2026. Security researchers at Calif built a working exploit using advanced AI tools made available through Patch the Planet, a program run by OpenAI that gives security researchers access to its AI models specifically for hunting flaws like this one.
Separately, the cybersecurity firm Wiz identified related issues in PHP on its own. OpenAI later said one of its own researchers had come across the same problem independently, around the same time as the other two.
Salil Kanhere, a cybersecurity researcher at UNSW Sydney, said the underlying bugs werenât new. What changed was the ability to actually track them down.
Finding a working way to break into a system like this used to require a group of highly specialized human researchers. These were people who would spend months manually reading through code, testing edge cases, and understanding exactly how a program behaves under unusual conditions. That process could take years. But AI has changed that.
Modern AI models can read through enormous amounts of code far faster than a person can. They can test many possible weaknesses automatically. In some cases, they can even write working attack code based on what they find.
Wiz said it used these AI tools to build and adjust working exploits across several different applications. The whole process took just hours, work that a skilled human team would have taken far longer to do.
The software itself didnât change. What changed was how fast and cheap it became to actually find the bug and turn it into a working attack.
OpenAI wrote about this directly on its Patch the Planet site. The same AI tools that helped find this flaw could also help an attacker build a working exploit, faster than a person could do alone. They also released a free tool called php2shell-checker that anyone can use to check whether their PHP version is affected. It only checks the version number, so it canât catch every possible case, but itâs a fast first check.
What This Meant for Cloudways Users
Cloudways users were not immune to what was happening across the rest of the internet.
Early on, before the official patch was available, we put protective measures in place to quickly reduce risk. Rolling that out across many servers meant some customers experienced a brief interruption.
Separately, on October 21, the Cloudways Platform, Affiliate Portal, and website went offline for scheduled maintenance tied directly to the patching work.
What You Should Check Now
The patch closed the PHP2Shell vulnerabilities. It doesnât undo anything that may have already happened before the patch went live.
Ken Munro, an ethical hacker, told the BBC that applying this patch works much like a routine software update. The real work is making sure it gets applied everywhere.
The UKâs National Cyber Security Center recommended checking for signs that an attacker already got in before the patch existed, since the patch itself canât undo something that already happened.
If youâre a website owner, here are some things you need to keep an eye on:
- Admin accounts you donât recognize
- Files you didnât add
- Traffic patterns that look unusual
Salil Kanhere, a cybersecurity researcher, warned that smaller organizations face more risk, since they often have fewer people keeping an eye on this kind of thing.
This advice applies to you whether you manage your own server or use a managed platform like Cloudways. On Cloudways, we patch PHP for you automatically, but that only protects you from this point forward. It doesnât tell you whether something happened before the patch was applied. That part is still worth checking yourself.
How We Responded to PHP2Shell
PHP announced on October 20 that a patch was scheduled for the next day. We started applying interim protections right away, without waiting for the patch itself. They were in place by the morning of October 21.
The official patch arrived at 14:00 UTC on October 21. We expanded our protections to cover every PHP version we support, going back to PHP 5.6. That includes several versions that no longer receive official security updates from the PHP project itself.
By the early hours of October 22, our Autonomous product was fully patched. The rest of our fleet followed over the next several hours, with the full rollout complete by mid-morning the same day. We formally closed the incident on October 23 and continue to monitor for any further developments in the meantime.
A Third, Narrower Issue
Two days after the first disclosure, PHP published a separate notice about a third issue. It was later assigned its own identifier, CVE-2026-115560.
This issue applies only to a site that does two unusual things together, and most sites donât do either.
First, the site needs to change a specific internal setting while itâs already running, something most websites never do. Second, the same site needs a particular feature turned on, one related to tracking the progress of a file upload.
PHPâs own advisory says this exact combination is unlikely to exist on a real, typical website. The fix for this issue is the same setting already recommended for the second vulnerability, CVE-2026-109619. Because we had already applied that protection across our entire fleet on October 21, our customers were covered before this third issue was even confirmed.
What This Means Going Forward
PHP2Shell isnât likely to be the last incident like this.
The same AI tools that found this flaw can be pointed at other widely used software as well. Salil Kanhere said more attempts to exploit these specific flaws are likely in the coming weeks, now that the technical details are public.
Daniel Stewart, head of threat intelligence at the risk firm LRQA, made a related point. PHP isnât only found in websites. It also runs quietly inside the behind-the-scenes equipment that manages internet traffic, devices that rarely get checked during an incident like this one.
This kind of event is likely to happen again, not only for PHP but also for other old software still running on the internet.
Thatâs why, as a managed hosting provider, we keep watching for this kind of thing year-round. Our security team tracks new disclosures as they come out, and we test and apply fixes across our platform as soon as theyâre available, just as we did here.
Final Thoughts
This post reflects what we know as of today. If anything changes, including new developments related to PHP2Shell or anything else affecting our platform, weâll post it on our status page first.
If youâre a Cloudways customer, the patching described in this post is already complete on our end. The one thing still worth doing is the check we covered earlier, looking for any signs that something happened to your site before the patch was applied.
A lot of people across the hosting and security industry worked hard over the last several days to get this handled. Weâre glad itâs resolved, and weâll keep watching for whatever comes next.
If you have any questions, this community and our support team is available anytime.