The trap of a legitimate bug
In October 2026, the web faced two critical vulnerabilities in PHP — known as PHP2Shell (CVE-2026-109618 and CVE-2026-109619) — that exposed something far deeper than a code error: the reality that AI has turned legacy bugs into real, accessible attack vectors. The vulnerabilities affected up to 70% of the world's websites, including hospitals and governments, but what drew attention was not the technical severity — it was the speed with which attackers and defenders used AI tools to transform problems known since 2024 into active exploits.
What happened
The vulnerabilities were discovered by researchers at the AI security auditing company AI41 during a routine PHP audit. The flaw was in how PHP 8.3 generated session tokens and processed file uploads — the same pattern that appeared in separate PHP bugs in 2024. That time, the bugs were fixed. But the fundamental pattern remained: PHP continued to generate predictable tokens, and the upload processing logic contained flaws that, when combined, allowed remote code execution.
When the CVE was issued in September 2026, AWS reported that it had already suffered over 3,000 exploitation attempts before the CVE was even published — a number that rose to more than 100 million in the following months. According to AWS, the attempts began in mid-2025, months before the public disclosure of the flaws, indicating that knowledge of the exploitation vector was already circulating among malicious actors.
Cloudflare, meanwhile, reported that over 3 million malicious requests were blocked throughout 2026, with the peak concentrated in October. But the most disturbing data came from The Hacker News: Cloudflare processed over 100 million exploitation attempts in 2026 — a number that includes not only PHP2Shell but related variants of other legacy PHP bugs.
The central role of AI
The fundamental difference between PHP2Shell and previous vulnerabilities is that AI tools are present on both ends: both the researchers discovering the flaws and the attackers exploiting them.
The AI41 researchers used automated analysis tools — essentially, AI agents configured to interpret PHP source code — to find vulnerability patterns in millions of lines of code. What took months to do manually was done in hours. But the same mechanism operates on the other side: the same class of tools allows any attacker with basic access to code LLMs to identify insecure patterns in legacy projects.
Wired called this phenomenon the "PHP Meltdown" — and the term is more than sensationalism. The reality is that bugs that had existed since 2024 were transformed into functional exploits thanks to the dramatic reduction in barrier to entry for exploitation. AI tools allow attackers to translate bug descriptions into exploitable code, test variations automatically, and optimize payloads against specific systems.
The effect is an accelerator of lifecycle: the time between the existence of a bug and its active exploitation drops from months to days. And it is not just PHP. The same pattern is observable in other 2025-2026 vulnerabilities, where AI reduced the distance between "known bug" and "active exploit" to an unprecedented degree.
Trust architecture under pressure
What PHP2Shell reveals about web trust architecture is that it was designed for a world where vulnerability discovery and exploitation were niche activities — done by specialists with years of experience. When AI enters the equation, that distinction disappears.
AWS reported that PHP2Shell exploitation attempts began before the CVE disclosure, which raises the question: who was exploiting, and with what? Evidence points to a sophisticated group of actors who used AI tools to automate the search for legacy vulnerabilities across servers worldwide. It was not a directed attack on a specific target, but a mass automated sweep — the kind of activity that used to be done by relatively simple bots and now uses AI agents to identify and exploit multiple vectors simultaneously.
Cloudflare mitigated the problem by manually blocking most known payloads, but the mitigation lifecycle — from discovery to patch, from patch to exploitation, from exploitation to mitigation — accelerated to the point of being unsustainable under the current model. Each new PHP version fixes the problem, but the failure pattern persists in legacy versions that continue to run millions of sites.
What comes next
PHP2Shell is not just a specific vulnerability — it is a symptom of a structural shift in web security. When AI democratizes both the discovery and the exploitation of legacy bugs, the premise that vulnerabilities can be contained until a patch is available no longer makes sense.
The "discover, publish, fix" model — which worked for PHP for decades — now operates in slow motion relative to the speed with which AI transforms bugs into attack vectors. The question is: if every legacy bug can be turned into an exploit in days, what would be the next logical step for the security industry? The answer likely involves a trust model based on isolation, where third-party code execution occurs in independent sandboxes — the same reasoning that led to WebAssembly gaining traction in browsers, but applied to the server side.
Meanwhile, millions of sites continue to run PHP on legacy versions, vulnerable to exploits that AI makes increasingly accessible. PHP2Shell was not an isolated event — it was the moment when the web realized that the future of digital security does not lie in patches, but in fundamentally rethinking how legacy code coexists with AI agents operating at speeds no human could match.
Sources: Wired, The Hacker News, The Register
✓ Independent sources cross-checked and verified before publishing
