Who Found PHP2Shell: Humans or AI?

By Saif Ur Rahman Published 22 Oct 2026 Updated 22 Oct 2026
FactsFigs
0 shares
FactsFigs Data Story
Dot timeline of the PHP2Shell flaw. Four events from 2004 to 2024 run across the top with their years on the left, then six events through August to October 2026, ending on 21 October when working exploit code was first seen in public.

Who Found PHP2Shell, Humans or AI?

Both, at different stages. Humans had the weakness class since 2004 and the bug itself since 2024. AI is what finally produced a working exploit.

PHP’s own CVE record names OpenAI as the finder of CVE-2026-109618, with Calif and Wiz as reporters. All three say they used AI models. What makes the timeline worth reading is the twenty-two year gap before that. The same weakness class was documented in 2004. The vulnerable code shipped in 2012. A bug report touched the symptom in 2019. A security audit found the actual flaw in 2024 and theorized an exploit without ever building one. Then in August 2026, within three weeks, three independent teams built one.

! The two halves of the chart:

  • •
    Human found: Four events across twenty-two years. Each one got closer, and none produced a working exploit.
  • •
    AI assisted: Six events in under three months, from the first working path to public exploit code.
  • •
    Who is credited: The CVE record lists OpenAI as finder, Calif and Wiz as reporters, and four PHP developers as remediation.

Continue reading below for the full detailed article →

The flaw

Two Ways to Reach Code Execution Through Memory Handling

PHP2Shell is two flaws in PHP core, CVE-2026-109618 and CVE-2026-109619, both allowing unauthenticated remote code execution. The first is memory corruption during out-of-memory handling. The second is internal state that survives a fatal error and gets reused by the next request on the same worker process.

Both were patched on 21 October 2026 in PHP 8.5.12, 8.4.27, 8.3.36 and 8.2.35. PHP scored them 9.2 on CVSS v4.0; the National Vulnerability Database scored the same pair 9.8 on the older v3.1 scale.

The earliest affected release Calif identified is PHP 5.4.0, which shipped on 1 March 2012. That makes the vulnerable code 14.6 years old at the point it was patched.

Human found

Four Times Humans Got Close Without Getting There

The slate half of the timeline is not a story of nobody looking. It is a story of people finding the right thing and being unable to finish it.

In July 2004 Stefan Esser documented CAN-2004-0594, where PHP terminated a request on hitting its memory limit at a point where internal state was unsafe, and showed that could reach code execution. That is the same weakness family, though not the same code path. Calif calls it the original memory-limit RCE.

In November 2019 bug #78876 recorded an out-of-memory crash with temporary files left behind. It was assigned its own CVE and fixed as a crash. Nobody connected it to a route to code execution.

The closest call came in 2024, when an external audit of PHP found what the PHP Foundation later described as the first signs of the out-of-memory problem behind CVE-2026-109618. An exploit was theorized. No concrete vector was found, and by the Foundation’s own account the fix stalled for want of a known path to remote code execution. That is the gap the 2026 work closed.

AI assisted

Three Teams, Three Weeks, and Every Model Named

The pink half of the timeline is six events between 1 August and 21 October 2026, and each team has published what it used.

Calif was first, on 1 August. Its write-up describes an agent noticing an ordering problem inside a PHP hash function during a source review, then tracing the root cause to automatic nested POST parsing and finding that mod_php shutdown consumes the malformed table. OpenAI says Calif identified the flaw using GPT-5.6 Sol under its Patch the Planet initiative. Calif reported on 11 August; OpenAI independently reported the same root cause the same day.

Wiz discovered its first bug on 19 August and reported on 24 August. Its account is the most specific about tooling: Wiz Atlas, Gemini 4 Argon and GPT-5.6 Sol were used throughout, and it credits Gemini 4 Argon with contributing to finding the vulnerability, developing the exploit, detecting attacks and validating the patch. OpenAI reported further attack vectors on 18 September.

The teams differ on what the models did beyond discovery, and the difference matters. Wiz says frontier models were critical to making the process practical and let it develop and adapt working exploits across multiple applications in hours. Calif says nothing about a model writing or adapting its exploit chain. On that stage, silence is not agreement.

Calif is also the most restrained about what happened. It says no special harness and no models beyond those generally available were used in the initial discovery, that it chose a target whose vulnerability patterns it already knew, and plainly that no model is simply capable of unearthing all bugs with simple prompts, at least for now.

The whole timeline

Every Dated Event in the Life of the PHP2Shell Flaw

The same ten events the chart plots, with who found each one and whether an AI model was named in the account.

14 Jul 2004Memory-limit abort reaches code execution (CAN-2004-0594)Stefan EsserHuman
1 Mar 2012PHP 5.4.0 ships the earliest affected code pathPHP projectHuman
28 Nov 2019Bug #78876 records an out-of-memory crash, no exploitPHP bug trackerHuman
2024Audit finds the OOM problem, exploit theorized onlyExternal audit of PHPHuman
1 Aug 2026First working remote code execution path foundCalif (GPT-5.6 Sol)AI assisted
11 Aug 2026Reported to PHP; OpenAI reports the same root causeCalif and OpenAIAI assisted
19 Aug 2026Second flaw discovered independentlyWiz (Gemini 4 Argon, GPT-5.6 Sol)AI assisted
24 Aug 2026Reported to PHPWizAI assisted
18 Sep 2026Further attack vectors reportedOpenAIAI assisted
21 Oct 2026Working exploit code seen in public, then patchedAmazon Threat IntelligenceAI assisted
Download this data (CSV) Compiled by FactsFigs from the CVE records and the discoverers’ own write-ups. Free to use with credit to FactsFigs.

The 2024 audit has no stated month in the PHP Foundation’s account, so only the year is given. "Discovery" records whether the party named an AI model in its own write-up, not whether a model acted alone.

What it does not prove

Nobody Has Measured the Difference

Three independent teams converging in three weeks is strong evidence that something changed in what is findable. It is not a measurement of how much, and it is one flaw.

The claim that would matter is that AI collapsed the cost of exploit development. Wiz puts a number on it: a single researcher completed in a week what would previously have taken a world-class team months. No source is given for the comparison, and every party making a version of this claim sells either AI or security products.

There is counter-evidence in the record too. PHP’s own CVSS v4.0 vector rates attack complexity high and marks attack requirements as present. Sansec reported on 22 October that public proof-of-concept code does not work against a default PHP installation. Whatever the models contributed, the attack did not become trivial.

What the timeline supports without stretching is narrower and still interesting: a weakness class documented in 2004 and a specific bug found in 2024 sat without a working exploit, and in August 2026 three independent teams built one within three weeks of each other, each naming the model it used.

Quick Answers

Did AI find the PHP2Shell vulnerability?

Partly. The PHP project’s CVE record for CVE-2026-109618 credits OpenAI as the finder, with Calif and Wiz as reporters, and all three describe using AI models. No account claims a model worked without a human researcher directing it, and Calif explicitly says no model can find all bugs from simple prompts.

Which AI models were used?

Calif used GPT-5.6 Sol, according to OpenAI, under its Patch the Planet initiative. Wiz used Wiz Atlas, Gemini 4 Argon and GPT-5.6 Sol, and credits Gemini 4 Argon with contributing to discovery, exploit development, attack detection and patch validation.

How long had the flaw existed?

The earliest affected release is PHP 5.4.0 from March 2012, making the vulnerable code 14.6 years old when it was patched. The same weakness class was documented by Stefan Esser in July 2004, 22.3 years earlier.

Why did nobody exploit it before 2026?

A 2024 audit found the underlying out-of-memory problem and theorized an exploit without building one. By the PHP Foundation’s account the fix stalled for want of a known path to remote code execution. PHP’s own severity vector still rates attack complexity as high.

Data Source and Attribution

CVE-2026-109618 record (PHP as CNA) The PHP Foundation security release post W3Techs PHP version survey CISA alert on the PHP vulnerabilities

Credits, the CVSS v4.0 score and its vector are read directly from the CVE record published by the PHP project as CVE numbering authority. The v3.1 score of 9.8 is the National Vulnerability Database’s.

Quotations describing what each AI model did are taken from the discoverers’ own write-ups, published 21 October 2026. OpenAI’s page could not be read directly at the time of writing, so its wording is attributed only where a named outlet reported it.

Dates on the timeline come from each party’s own account. The 2024 audit has no stated month, so it is placed mid-year and should be read as approximate.

Where sources disagree, both values are published rather than reconciled. That applies to the affected-version floor, the release timestamp and the CVSS scale. Claims about what AI changed are attributed to the party making them.

Last verified: 22 Oct 2026

The charts in this article were built with our own publishing system. See what it does →