PHP2Shell: Critical PHP Vulnerability and AI's Role

What this article covers

• What PHP2Shell is, why CVE-2026-109618 and CVE-2026-109619 received a CVSS score of 9.2, and which PHP versions are safe.
• How AI models were involved in discovery, exploit development, and patch validation, and what this means for AI in cybersecurity.
• What developers should learn from this case, even though the vulnerability didn’t originate from AI-generated code.
• How to check your PHP version, install the PHP2Shell fix, and search for signs of compromise.

Summary: On October 21, 2026, the PHP project released patches for two critical vulnerabilities in the PHP core. Anyone running a web server with PHP should immediately update to PHP 8.5.12, 8.4.27, 8.3.36, or 8.2.35 (or newer), then restart PHP-FPM or the web server. Germany’s Federal Office for Information Security (BSI) classified the situation at warning level 3 (orange) as exceptionally severe.

The apparent contradiction at the start

AI helped uncover one of the most complex security problems in PHP history. The underlying flaws had been sitting in the codebase for over a decade, and the exploit chain was considered so complex that it bordered on what humans could realistically achieve. Frontier models lowered that barrier, transforming a years-old bug into a working exploit.

At the same time, those same capabilities lower the entry barrier for attackers. Anyone analyzing a published vulnerability, adapting an exploit to a different environment, or interpreting error messages now gets assistance from a language model that would have required years of specialized expertise to provide manually. PHP2Shell is the first prominent case where both sides become visible simultaneously, which is exactly why it matters so much for everyone building with AI.

What is PHP2Shell?

PHP2Shell is the collective name for two vulnerabilities in the PHP core, tracked as CVE-2026-109618 and CVE-2026-109619. Both received a CVSS v4.0 score of 9.2 and can enable unauthenticated remote code execution, meaning executing code from a distance without credentials. The name deliberately echoes Log4Shell, the Java vulnerability from 2021.

The two vulnerabilities are memory errors (use-after-free, CWE-416) and affect different stages of request processing:

• CVE-2026-109618 (out-of-memory corruption): When memory allocation fails, PHP leaves invalid data that the request cleanup routine later treats as valid. The attack happens during multipart/form-data request processing and reaches the vulnerability before application code even runs.
• CVE-2026-109619 (stale global state): A PHP worker can reuse internal state from a previous request even though the associated memory was freed long ago.

Beyond code execution, researchers also demonstrated memory disclosure following the Heartbleed pattern. Attackers can read portions of the PHP process memory, including passwords, session tokens, API keys, and certificates from other requests. This attack form works without prior remote code execution and is correspondingly harder to detect.

Important for context: The problem lives in the PHP core, not in WordPress, Joomla, Drupal, TYPO3, a theme, or a plugin. These systems served as demonstration targets in the research, but the vulnerability affects any PHP application running on a vulnerable runtime, down to a simple script that just produces output. About 70% of all websites run on PHP.

Affected are installations that process web requests: PHP-FPM, Apache with mod_php, php-cgi, FrankenPHP, and LiteSpeed. Apache mod_php was rated as particularly critical because the demonstrated exploit triggers the vulnerability there even before application code runs, and because mod_php shares the same process space as the web server.

Which PHP version is safe?

PHP branch	Vulnerable	Safe from
PHP 8.5	all versions before 8.5.12	PHP 8.5.12
PHP 8.4	all versions before 8.4.27	PHP 8.4.27
PHP 8.3	all versions before 8.3.36	PHP 8.3.36
PHP 8.2	all versions before 8.2.35	PHP 8.2.35
PHP 8.1 and older (including PHP 7.x, 5.x)	affected, no official release	distribution backport or upgrade required

Essentially every version since PHP 5.4 is vulnerable. Old end-of-life versions like PHP 7.4 or PHP 8.1 are not automatically safe just because they don’t receive new releases. The PHP Security Team has provided source backports for PHP 7.4, 8.0, and 8.1, but whether your package includes the fix depends on your distributor. If you’re running an EOL version, you should switch to a supported branch anyway.

What role did AI play in the discovery?

PHP2Shell was discovered by Wiz Research (Sagi Tzadik, Shir Tamari, Nir Ohfeld, Tomer Schwartz) together with OpenAI Codex Security (Amy Burnett) and independent researcher Ryan A. from California. Primary sources document the use of three AI systems: Wiz Atlas, Gemini 4 Argon, and GPT-5.6-Sol, deployed in discovery, exploit development, and patch validation. According to the participants, Gemini 4 contributed particularly heavily to exploit development and patch validation. Google provided dedicated Gemini personnel as part of the coordinated disclosure process.

Specifically, the models helped in this PHP security research by working through complex memory errors, testing exploit chains, debugging, and adapting attacks to different environments (WordPress, Drupal, Joomla each in different container configurations). What human researchers previously would have spent months on in lab setup and debugging, the agents completed in roughly two weeks.

OpenAI describes the coordination under the title “Patch the Planet”: a coalition of maintainers, researchers, and security vendors worked together before publication, including the PHP Security Team, Google Cloud, Cloudflare, AWS, Microsoft, Automattic, Fastly, Akamai, Imperva, Vercel, Corelight, CrowdStrike, Unit 42, and Cisco Talos. These partners prepared detections and interim measures for customers who couldn’t patch immediately.

This is the part that needs separating: the use of models in the research is documented. The conclusion from that, namely that LLMs lower the cost of technical expertise on both the defense and attack sides, is an interpretation, but a well-supported one. The Wiz team itself speaks of an “AI inflection point” for vulnerability research.

The new attacker: why this matters for you

Those same capabilities that Wiz used are available to anyone with a chatbot subscription. LLMs lower the entry barrier into specialized technical fields because they explain complex security concepts, contextualize public CVEs, interpret error messages, automate repetitive work, adapt existing tools, and accelerate research.

This doesn’t mean a chatbot turns everyone into an exploit developer. A critical PHP remote code execution like PHP2Shell still requires memory layout understanding and knowledge of PHP internals. But the barrier drops structurally: the share of specialized knowledge that lives in a model rather than a person grows. What a research team achieves today with frontier models, a skilled individual might pull off tomorrow. Defenders need to calibrate their patch and monitoring processes for this acceleration. See AI in Cybersecurity for the broader context and AI Pentest Agents Compared for the state of autonomous attack tools.

What Vibe Coders Should Learn from PHP2Shell

Let me start by clearing up a misconception that’s been spreading online: PHP2Shell wasn’t caused by Vibe Coding or AI-generated code. The vulnerabilities had been sitting in human-written PHP core code for over a decade. Still, this case matters enormously for anyone using AI to code, because it exposes the central weakness in modern development workflows: working code isn’t automatically secure code.

Here are the typical risks that AI-assisted programming introduces, which this incident highlights:

• Lack of understanding of generated code: If you can’t follow what the code does, you won’t spot security flaws in it.
• Missing code reviews: Generated code ships to production without scrutiny.
• Unvetted dependencies and outdated libraries: AI suggests package versions it knows from older training data.
• Insecure default configurations: Debug modes enabled, overly permissive CORS rules, missing rate limits.
• Authentication and session bugs: Exactly the areas where generated “it works” code most often hides problems.
• Unsafe file uploads and missing input validation: The PHP2Shell attack surface is multipart request handling, precisely the code path that Vibe Coding projects often adopt without review.
• Secret and API key leaks: Keys embedded in code, logs, or frontend bundles.
• Excessive permissions: Containers running as root, database users with DROP privileges, agents with production access.
• No patch management: Generated stacks get deployed and then never updated, which is exactly what’s making PHP2Shell a ticking bomb right now.
• Unreviewed agent actions on production servers: If a coding agent deploys autonomously, you need control layers from agent security, such as approval gates and sandboxing.

None of these problems are new; humans have been making them for decades. AI scales them because more people ship code to production faster. But the same AI can improve security if you use it deliberately for reviews, dependency checks, and tests instead of just code generation. For the review angle, see AI code review, and for the agent side, check coding agents.

How to Check If Your Server Is Affected by PHP2Shell

First step: find out what PHP version your command line is running.

php -v

or equivalently:

php -r 'echo PHP_VERSION, PHP_EOL;'

Important: The CLI version may not be the one serving your website. Apache might load a different mod_php, or PHP-FPM could be running multiple pools with different versions. Also check the actual runtime in use:

# Which PHP-FPM services are running?
systemctl list-units --type=service | grep -i php
ps aux | grep php-fpm | head

# What version is the running PHP-FPM process?
php-fpm8.4 -v        # adjust path/binary name for your distribution

With Apache and mod_php, the version is in the loaded module; check it through your package manager (apt policy libapache2-mod-php8.x) or create a temporary diagnostic script. HTTP headers sometimes leak the PHP version (X-Powered-By), but they’re unreliable since many servers suppress them.

Warning about phpinfo(): A publicly accessible phpinfo() script reliably reveals the version but also exposes configuration details. If you use it for diagnostics, delete the file immediately afterward or block access to it. It’s not a long-term solution.

On managed hosting, you’ll usually find the PHP version in your control panel (Plesk, cPanel, or host-specific interfaces) and can often upgrade directly there.

The official resource for upgrade guidance and response help is php2shell.com, run by the researchers who discovered the issue. It also lists the NCSC-NL directory of affected third-party software. Be aware of each check’s limits: a version check isn’t a penetration test. A result saying “patched” doesn’t prove the system was never compromised before, and an unclear result doesn’t automatically mean you’re secure.

How to Protect Your Server from PHP2Shell: Immediate Steps

1. Inventory your PHP versions: Find every runtime that handles web requests, including Docker containers and secondary instances.
2. Upgrade to the patched version: PHP 8.5.12, 8.4.27, 8.3.36, or 8.2.35, or the distribution package with backport.
3. Restart PHP-FPM and your web server: Old worker processes will otherwise continue running the vulnerable version.
4. Verify which version is actually serving requests: After restart, check again using the methods above.
5. Review your logs: Check web server and PHP logs for the signals described in the next section.
6. Look for suspicious files and changes: New PHP files, altered upload directories, unknown cron jobs, and unfamiliar user accounts.
7. Rotate secrets if compromise is suspected: The memory disclosure may have exposed tokens and keys; see automating secret rotation.
8. Replace unsupported PHP versions: PHP 7.x and 8.1 need to move to a maintained branch.
9. Test your backups and recovery: If your system was compromised, a clean restore is the fastest way back.
10. Start incident response if needed: Isolate the system, investigate forensically, and get details at IRC-Security.de.

A Web Application Firewall adds a useful layer: Cloudflare, AWS, and others have published PHP2Shell-specific rules that reduce known attack paths. But no firewall fully prevents the PHP vulnerability; the attack surface lies below the application level. The PHP security update is the only complete fix.

Updating by Environment

• Debian/Ubuntu: apt update && apt upgrade updates the PHP packages. Be careful with backports: the upstream version shown by php -v doesn’t prove the distribution package is patched. Also check the security advisory and package changelog (apt changelog php8.x-cli or the distribution’s tracker page).
• Fedora/RHEL-like systems: dnf update php or the corresponding module. Same caveat about vendor backports; the package changelog is what matters (rpm -q --changelog php).
• Docker: Pull the base image up to a patched version and rebuild the container, details in the next section. An update inside a running container won’t survive the next restart.
• PHP-FPM: After the package update, run systemctl restart php-fpm (name varies by version, like php8.4-fpm), then verify that new workers are running.
• Apache mod_php: systemctl restart apache2 or httpd, then verify the loaded module version.
• Managed hosting: Switch PHP versions in your control panel or contact your host. Many providers have already patched in response to the BSI PHP security alert.

The patch introduces a new hard memory limit: if a process reaches it, the process is killed and shutdown handlers don’t run. After updating, verify that your application is compatible with this change.

Securing PHP2Shell in Docker Containers

A container isolates the application from the host, but not the PHP vulnerability itself. If a vulnerable PHP interpreter runs inside the container, remote code execution is just as possible, only with the container user’s privileges. From there, mounted volumes, environment variables holding database passwords and API keys, and depending on configuration a path to the host are all exposed. For a PHP2Shell check in Docker environments, proceed as follows:

1. Check the PHP version inside the container

# Which PHP containers are running?
docker ps --format '{{.Names}}\t{{.Image}}'

# Version inside the running container
docker exec <container> php -v

What matters is the version inside the image, not the one on the host. php -v on the host tells you nothing about containers, and the same applies to phpinfo(): the file belongs in the container context and must be removed right after.

2. Update the image, don’t patch the container

The official PHP images on Docker Hub have been rebuilt with the fixed versions. Set the tag in your Dockerfile or docker-compose.yml to a patched version, for example php:8.4.27-fpm or php:8.5.12-apache, then:

docker compose pull        # pull the current base image
docker compose build --pull
docker compose up -d       # recreate containers

Important: docker compose restart is not enough, it restarts the same container with the same image. The PHP2Shell patch only reaches the container through a rebuilt image. If you use digest pinning (php:8.4-fpm@sha256:...), update the digest to the new build. After the restart, verify with docker exec <container> php -v.

3. Harden the container

• Don’t run as root: USER directive in the Dockerfile or user: in the compose file
• Read-only root filesystem where possible (read_only: true), restrict write access to defined volumes
• Don’t pass secrets as environment variables; use Docker secrets or mounted files instead. The memory disclosure component of PHP2Shell can read process memory, and environment variables sit there in plaintext. If you suspect compromise, rotate credentials, see automating secrets rotation.
• No unfiltered application access to the Docker socket

4. Check for compromise inside containers

Containers themselves are ephemeral; persistence lives in volumes. Search mounted directories for new or modified PHP files, especially WordPress upload paths (wp-content/uploads). The signals from the compromise section apply equally, except that logs often live inside the container or the orchestrator (docker logs, the log view in Coolify).

If you run a home server with Coolify or Docker Compose, you’ll find a concrete walkthrough including a WordPress check at PHP2Shell: check and secure WordPress, Docker, Coolify and home servers now on IRC-Mania.de.

Is WordPress Affected by PHP2Shell?

WordPress itself isn’t the source of the vulnerability, but it runs on PHP and is therefore just as exposed on a vulnerable runtime as any other application. WordPress, along with Drupal and Joomla, was one of the demonstration targets where researchers showed unauthenticated remote code execution.

What this means for you:

• A WordPress core, theme, or plugin update does not close the PHP server vulnerability. You need the PHP security update on the server itself.
• With shared hosting, the provider controls the PHP version: you’ll find the configured version in your control panel (Plesk, cPanel, or similar). When in doubt, contact support.
• If you run your own VPS, update PHP yourself as described above.

The same answer applies to PHP2Shell Joomla and PHP2Shell Drupal: the CMS isn’t the problem, the runtime underneath is.

Signs of Possible Compromise

A successful update doesn’t prove your server was clean beforehand. Researchers identify these investigation signals:

• Unusual HTTP POST requests, especially multipart/form-data with high volume.
• Repeated PHP out-of-memory errors in logs.
• Suspicious HTTP 500 errors occurring in clusters.
• PHP-FPM or Apache workers crashing or restarting more frequently than normal.
• Unexpectedly large or malformed PHPSESSID response cookies.
• New or unexpectedly modified PHP files, particularly in WordPress upload and theme directories.
• Webshells, disguised PHP files that accept commands.
• Unknown cron jobs and user accounts.
• PHP or web server processes spawning shells, interpreters, or download utilities.

These signals help guide your search, but individually they prove nothing, and their absence doesn’t prove the system hasn’t been compromised. Some attack paths only read memory without executing code, leaving barely a trace in application logs. If you have concrete suspicion: isolate the system and conduct a forensic investigation. The AI log checker for Linux logs helps with systematic log analysis, and Hardening Linux servers with rkhunter, Lynis, and AI covers post-incident hardening.

Reports on exploitation status are conflicting: on October 21, the BSI reported no confirmed attacks but unconfirmed reports of existing exploits. Amazon, however, reported that its threat intelligence systems had already observed PHP2Shell exploitation before public disclosure. Details about the vulnerability also leaked before the scheduled release date, adding additional urgency.

AI as a Security Tool: The Constructive Side

PHP2Shell doesn’t show that AI produces bad software. It shows that AI lowers the cost of technical expertise on both sides. The same capability that enabled researchers to find the vulnerability is available to you as a defender:

• Explain code: understand unfamiliar code paths before they go into production.
• Run security reviews: “Check this code for typical vulnerabilities” is a useful first pass.
• Audit dependencies and versions: take inventory and cross-reference against advisories.
• Generate tests: including security-relevant tests for input validation and auth flows.
• Identify dangerous functions: eval, exec, unvalidated include, direct query concatenation.
• Analyze logs: the signal-hunting from the previous section works well with AI assistance.
• Summarize security advisories: translate BSI and vendor bulletins into action items.
• Review changes before deployment: check diffs against known error patterns.

One boundary remains: AI can support security reviews but shouldn’t be the final unchecked authority. Models miss context-dependent issues and can create false confidence. For the deeper technical aspects of PHP, web servers, and server operations, IRC-Coding.de with its PHP and Linux tutorials is the right sister site.

Frequently Asked Questions About PHP2Shell

What is PHP2Shell?

The collective name for two critical memory safety bugs in the PHP core (CVE-2026-109618 and CVE-2026-109619) that enable unauthenticated remote code execution and memory disclosure. The name echoes Log4Shell from 2021.

How dangerous is PHP2Shell?

CVSS v4.0 score of 9.2 for both vulnerabilities. PHP powers roughly 70% of all websites, these bugs can be exploited remotely without authentication, and a proof-of-concept exists. The BSI rated the situation at orange alert level, marking it as exceptionally critical.

Did AI discover PHP2Shell?

AI models played a significant role: Wiz Research used Wiz Atlas, Gemini 4 Argon, and GPT-5.6-Sol for discovery, exploit development, and patch validation. Human researchers from Wiz, OpenAI Codex Security, and Calif found and reported the vulnerabilities themselves.

Did AI Coding cause PHP2Shell?

No. The bugs had existed in the human-written PHP core for over ten years. The case remains a warning about AI coding security risks because it shows that working code doesn’t automatically mean secure code.

Can AI find security vulnerabilities?

Yes, this is the most prominent evidence to date. Frontier models helped construct an exploit chain at the edge of human capability. But the same ability also helps defenders with code review and patch analysis.

Can AI help hackers?

LLMs lower the entry barrier: they explain CVEs, interpret error messages, and adapt tools. An RCE like PHP2Shell still requires specialized knowledge. The trend is clear, though: technical expertise becomes cheaper for both sides.

Is AI-generated code insecure?

Not inherently. It becomes insecure when deployed to production without review, dependency checking, or patch management. AI used deliberately improves security more often than not, as discussed in the section on AI as a security tool.

How do I check my PHP version?

Run php -v on the command line, but be careful: that might be a different version than what PHP-FPM or Apache actually uses for your website. Check the web runtime through running services, your package manager, or your hosting control panel.

Which PHP version fixes PHP2Shell?

PHP 8.5.12, 8.4.27, 8.3.36, and 8.2.35 or later. For PHP 8.1 and older there are no official releases, only source backports that distributions can include. You should replace older versions anyway.

Is my WordPress site affected by PHP2Shell?

If it runs on a vulnerable PHP version, yes, like any PHP application. WordPress itself isn’t the cause. A CMS update alone won’t help, the server needs the PHP security patch. Check your hosting control panel for the version.

Are Joomla and Drupal affected?

The same way WordPress is: both were demonstration targets for these attacks. Here too, a CMS update doesn’t replace the PHP2Shell patch on the runtime.

Can a firewall completely prevent PHP2Shell?

No. WAF rules from Cloudflare, AWS, and others weaken known attack paths but don’t cover all variants. They’re a stopgap measure, the PHP update remains mandatory.

What should I do with PHP 7.x or PHP 8.1?

These are end-of-life versions without official fixes. Check whether your distribution offers a backport package and plan a migration to a supported branch. EOL versions are a persistent risk regardless of PHP2Shell.

Do I need to restart after updating?

Yes. Restart PHP-FPM pools and the web server, otherwise old workers keep running the vulnerable version. Afterward, verify which version is actually serving requests.

Could my server already be compromised?

Possibly. There are reports of exploitation before public disclosure, and memory-disclosure attacks leave few traces. Check the signals in the compromise section, and if you suspect foul play, isolate the system and conduct forensics.

Sources and Further Reading

• php2shell.com: Official portal from the discoverers, with upgrade guidance and mitigations.
• Wiz Research: PHP2Shell: Technical research report, including the AI inflection point.
• OpenAI: Patch the Planet: Coordinated disclosure from OpenAI’s perspective.
• PHP Foundation: Security Release: The official PHP statement.
• BSI Cybersecurity Warning 2026-297981-1032: German BSI PHP vulnerability alert, warning level orange.
• ENISA Joint Statement: Joint statement from the European Commission, ENISA, CERT-EU, Europol, and national CSIRTs.
• NCSC-NL: Affected Third-Party Software: List of products containing PHP.
• Cloudflare: WAF Protection and AWS Security Blog: Interim measures for operators.
• Datadog Security Labs: Analysis: Technical depth on both CVEs and detection approaches.
• PHP2Shell on IRC-Coding.de: The in-depth PHP vulnerability article focused on the technical update guide.
• PHP2Shell: securing WordPress, Docker, Coolify and home servers: The hands-on variant for home-server and self-hosting operators on IRC-Mania.de.

What PHP2Shell Really Reveals

PHP2Shell is not a story about bad AI code. It is a story about the new economics of expertise. On the attack side, AI turned a decade-old vulnerability into an exploit in weeks, work that once demanded months of specialist effort. On the defense side, those same models helped validate patches, and OpenAI coordinated the global response. If you build with AI, use the defensive capabilities just as vigorously as the offensive ones. Code reviews, dependency checks, log analysis, and patch management are cheaper today than ever before, just as cheap as finding bugs in the first place.