The PHP2Shell vulnerabilities made it possible to execute code on a vulnerable server without authentication, and their disclosure sparked disputes among PHP developers, researchers, and vendors. For teams maintaining services, the practical lesson is simple: it’s not enough to obtain a fix; you also need to know exactly where PHP is running and who is responsible for updating it.
The incident exposed several weak spots at once: prolonged decision-making in an open project, inconsistent releases of patched builds, and uncertainty about the actual scale of exploitation. Skepticism toward high-profile warnings was understandable, but it didn’t remove the need to check systems. When you start taking inventory in the middle of an incident, it suddenly becomes urgent and very manual work.
What happened in PHP
The name PHP2Shell covers two vulnerabilities: CVE-2026-109618 and CVE-2026-109619. Both received a score of 9,2 under CVSS 4.0. Their shared danger was the possibility of remotely executing code with the privileges of the PHP process handling web requests. No authentication was required.
The first bug occurred when PHP hit its memory limit while building internal request data. Subsequent request cleanup could treat partially created data as valid, resulting in memory corruption. In the second case, references to already freed memory remained after a request finished. The next request handled by the same worker process could access those references before the process state was reset.
Exploitation depended on configuration: PHP extensions, web server behavior, and how data was laid out in memory all mattered. So reproducing a bug and reliably exploiting it across different systems are not the same thing. This partly explains why researchers could get different results while testing the same vulnerabilities.
Why the fix was delayed
According to the PHP Foundation’s report, the first signs of memory exhaustion issues were detected back in 2024, but at the time no connection to remote code execution was established. Proposed fixes affected compatibility, performance, and third-party extensions. The team making decisions by consensus couldn’t agree on an acceptable option, and work on the changes was halted and resumed several times.
In August 2026, researchers at Calif shared results with the developers that already demonstrated remote code execution. In its report, the Foundation’s members acknowledged a systemic problem in decision-making and a lack of resources. This doesn’t mean the developers knowingly ignored a known critical vulnerability: early on, the specific attack method had not yet been established, and a fix could have caused other problems.
The complexity became apparent even after the patch was released. When parsing a large XML document, some PHP builds terminated the worker process instead of returning an ordinary out-of-memory error. A separate fix had to be prepared for the XML extension. This trade-off wasn’t theoretical: changing behavior under memory exhaustion affected compatibility with extensions.
The PHP Foundation has already begun changing its processes: instead of requiring consensus, it plans to make decisions by majority vote, and complex issues are supposed to reach leadership faster. The Foundation created a separate security team in May 2026, and it helped analyze new reports. However, its existence alone didn’t resolve the dispute over the fix, which had started earlier.
The shortage of specialists is another part of the problem. After Heartbleed in 2014, the Linux Foundation created the Core Infrastructure Initiative to fund the maintenance of critical open-source projects. The PHP Foundation, meanwhile, continues to urge organizations that use its code to fund specialist work. Without people, it’s hard to verify vulnerability reports, prepare compatible changes, and promptly submit information to knowledge bases. How quickly teams can match warnings to their software depends on these processes, too.
Premature release and a dispute over risk
By October 2026, the fixes were ready, but package and container image vendors needed time to prepare their own builds. After the CVE identifiers leaked, the release was moved from 22 to October 21. Later, an exploit demonstration video was published by mistake, and copies quickly spread.
On the morning of October 21, Chainguard released patched container images more than six hours ahead of the agreed time. For users, this wasn’t an automatic PHP update on any server: these were new images, so switching to them could require changing the deployment method. Administrators who installed PHP from a distribution repository had to wait for a package from their vendor.
Chainguard CEO Dan Lorenc explained that his team had learned of possible exploitation, found the issue themselves, and prepared an exploit. He said he discussed the situation with researchers, decided to publish patched images, and immediately informed the other participants. He believed that after the leak, waiting longer would leave users without an update that was already available. The PHP Foundation insisted on a coordinated release time so other vendors could also prepare packages. So the dispute wasn’t just about the clock; it was about what to do when the agreed plan has already been broken.
At the same time, debate continued over how easy PHP2Shell was to exploit. Some public PoCs didn’t demonstrate the claimed compromise of an ordinary PHP installation, and VulnCheck reported that only a small portion of the samples it reviewed contained a working exploit. Meanwhile, on October 22, VulnCheck prepared an exploit for PHP 8.4.26 on 64-bit x86 systems. It bypassed ASLR and worked with PHP error display disabled; a memory leak helped identify the required addresses.
At first, researcher Lucas Leutjes criticized calls to shut down websites, citing the Netherlands as an example. In his view, traffic and load balancing could make it difficult for an exploit to direct the required requests to a single PHP process on busy sites. But later, evidence of attacks emerged. A researcher using the handle 0×4D31 published logs from three honeypot servers: in 35 cases, attackers’ requests were followed by a command shell starting up.
Dream Research described a campaign targeting PAN-OS, the Palo Alto Networks firewall software. According to the company, the attacker compromised 25 servers by combining PHP2Shell with the Fragnesia Linux kernel vulnerability to escalate privileges. Unit 42 confirmed the tools and the campaign’s results: access was obtained through PAN-OS management web interfaces exposed to the internet.
Intruder engineer Benjamin Marr also initially doubted the scale of the threat and tested it on PAN-OS. The first version of the exploit worked when connected directly to Apache on the device, but external access through nginx broke the chain. In his update of November 3, Marr demonstrated command execution through the PAN-OS 12.1.2 management interface after changing the way memory was leaked. He concluded that for a widely used product with identical builds and PHP settings, it was enough to find a chain once to apply it to similar devices.
James Pavur’s server test did little to dispel doubts either. He invited researchers to try to hack his PHP server and take bitcoins worth about 500 dollars. The exploit was adapted to the server’s configuration, and a participant in the test obtained the secret. The key itself couldn’t be used to transfer funds from the target wallet, so the reward had to be sent separately. Pavur admitted that he had underestimated the threat. It’s a good example of the difference between “it didn’t work with this PoC” and “it can’t be exploited”—a small distinction, but an important one for the next report.
PHP may be in your product even if your team doesn’t use it
For the owner of a product like PAN-OS, the first practical step was a vendor update, even though the internal team might not write PHP at all. A vulnerable interpreter can be part of a third-party solution, a container image, or a runtime environment. PHP can also be installed on a server separately or provided by a hosting provider. In applications, a similar invisibility arises from transitive dependencies: a developer adds a package that, in turn, pulls in other components.
That’s why a list of your own code doesn’t give you the full picture of what a service needs. An organization may not know that a particular system uses PHP until it checks its infrastructure or builds the software from source. This work will have to be done during an incident anyway, but there’ll be less time for it.
After obtaining a patched build, you need to install it on affected systems and check the version of PHP that’s running. Before that, you need to understand which systems are at risk, what exactly the vendor updates, and what you’ll have to change yourself. An agreed disclosure time can help vendors prepare fixes, but it won’t create an inventory of components for the user.
This requires ongoing responsibility for the software inventory, its dependencies, and runtime environments. The source mentions GOST R 56939–2024 and a draft standard for composition analysis, where the term “attracted software” is used for development tools and runtime environment software. Such an inventory should preserve the link between a component, the applications that depend on it, and those responsible for updates. Then a vulnerability in a runtime environment can be mapped to services, even if their code hasn’t changed in ages.
Organizations that buy ready-made solutions should ask vendors in advance which components and environments are included in the product, how vulnerabilities in them are reported, and how quickly fixes are released. Developers need to maintain this information alongside the product. In the case of PHP2Shell, one of the main questions after the patch appeared wasn’t “Do we have PHP in our own code?” but “Where is it actually running, and who can update it?”









