← Back to Blog

PHP2Shell: critical flaw in PHP core allows remote code execution (CVE-2026-109618, CVE-2026-109619 and CVE-2026-115560)

Threat intelligence analysis of PHP2Shell: two memory flaws in PHP core (CVSS 9.2) and the new, still unpatched CVE-2026-115560. See what the advisories confirm, the exploitation under way, and how to fix, mitigate and detect.

G
Gila Security
October 21, 2026
PHP2Shell: critical flaw in PHP core allows remote code execution (CVE-2026-109618, CVE-2026-109619 and CVE-2026-115560)

On October 21, 2026, the PHP security team released fixes for two critical vulnerabilities in the language core. They allow remote code execution (RCE) and were registered as CVE-2026-109618 and CVE-2026-109619, both rated CVSS v4.0 9.2. The pair became known as PHP2Shell.

The details leaked on October 20, and PHP moved the release up from Thursday (October 22).

If any server, container or system in your company runs PHP and takes traffic from the internet, update today. This article collects what the official sources confirm, what is still uncertain, and what to do in each case.

How this article was made. We used the official security advisories from the php-src repository and the analyses by Wiz, Sansec, Huntress and Upwind. Where the sources disagree, we say so. We do not publish exploit code.

Update: 10/23. PHP published an informational advisory about a third CVE, CVE-2026-115560, which is not fixed by the October 21 releases. It only affects an unusual combination of configuration and code, and the mitigation is simple: session.upload_progress.enabled=0. See the update section.

Executive summary

  • What it is: two use-after-free memory flaws, caused by how PHP handles fatal errors, mainly running out of memory (OOM), during a request.
  • Impact: unauthenticated code execution with the privileges of the web server user (for example www-data), plus process memory disclosure.
  • Who is exposed: web servers running PHP, mainly Apache with mod_php. PHP-FPM is less exposed, but not immune.
  • Fix: PHP 8.5.12, 8.4.27, 8.3.36 or 8.2.35. Versions 8.1 and older have no official fix.
  • Mitigation: no configuration fully solves the problem. Updating is the only reliable fix.
  • Update: 10/23: a third CVE, CVE-2026-115560, was announced and is not fixed in the versions above. Mitigation: session.upload_progress.enabled=0. See the update section.

Timeline

Date (UTC)Event
2026-08-19Wiz Research discovers the first flaw.
2026-08-24Wiz reports the problem to the PHP security team.
2026-09-21PHP acknowledges the report and starts a coordinated fix.
2026-10-20The details leak in a Hacker News post (later removed) and watchTowr confirms the flaws are real. PHP moves the release up.
2026-10-21, 07:43According to Sansec, Cloudflare reports the first attacks.
2026-10-21, 14:00PHP releases 8.5.12, 8.4.27, 8.3.36 and 8.2.35.
2026-10-21 (time not reported)Update: 10/23: watchTowr observes exploitation of both CVEs in its honeypots.
2026-10-23, 10:12Update: 10/23: PHP publishes the informational advisory on CVE-2026-115560, still unfixed. The fix will come in the next regular release.

Sansec records that Calif found RCE paths on August 1 and reported the first bug on August 11. According to Wiz, Calif and OpenAI collaborated on discovery, coordination and patch verification.

What are the flaws?

Update: 10/23: there is now a third CVE, described below, whose root cause has not been published. The first two share the same root: when a request ends abnormally, PHP does not safely clean up what was left in memory. A reused worker process can then use data that has already been freed.

CVE-2026-109618: corruption caused by running out of memory

To exit an out-of-memory error, PHP uses a function called longjmp(), which abandons everything at once. The problem appears when the allocation fails while the request is still partially initialized: PHP does not account for that early exit and, when ending the request, processes invalid state.

The official advisory (GHSA-w8hw-w9fx-j79w) describes ways to push a request into this error without visibly exceeding limits:

  • multipart requests with no usable declared size, which pass the initial post_max_size check;
  • parts with an unlimited number of headers, which take far more memory inside PHP than they do on the wire;
  • empty file fields, which do not count toward max_file_uploads but still create metadata structures, and the effect multiplies with nested field names.

CVE-2026-109619: global state that outlives the request

PHP workers keep global state for errors, sessions, objects and extensions. That state can keep pointing to memory from a request that has already finished. Some operations run before normal request initialization, read those values and trigger the use-after-free (GHSA-6wmf-4rv5-p3rp).

The advisory describes two pieces that have to meet:

  • What leaves the state behind: fatal errors, such as parse or compile failures, a failed require, execution timeouts and running out of memory.
  • What uses that state later: configuration (INI) diagnostics raised before initialization and the session upload progress handling, which is enabled by default.
  • Condition: both must happen on the same worker, in different requests.

CVE-2026-115560: session serialize handler switched at runtime

Update: 10/23. This flaw was announced after the first two and is not fixed in the October 21 releases.

Unlike the first two, PHP has not yet published the technical advisory, the CVSS score or the affected versions, and has not explained the root cause. What the October 23 notice says is that the problem involves session upload progress tracking and only occurs in an unusual combination:

  • the configuration sets session.serialize_handler to php_binary or php_serialize;
  • application code switches the handler back to php with ini_set() before session_start();
  • upload progress is still enabled, which is the default.

PHP states that, in that combination, an attacker could achieve remote code execution. It is not yet known whether the root cause is the same as CVE-2026-109619, which also goes through upload progress, so we do not treat the two as the same problem. See the analysis and workaround.

What Wiz demonstrated

Wiz’s analysis describes four variants: a use-after-free in the upload-progress handling, remote process-memory disclosure (returned in a PHPSESSID cookie), a use-after-free in the fatal-error backtrace, and a type confusion in OPcache.

The disclosure works even if the application never calls session_start() and can expose data from other requests. Sansec cites passwords, session tokens, API keys and TLS private keys as examples of what that memory can contain.

Wiz does not make clear which CVE corresponds to each variant, so we do not map them here.

Who is exposed?

EnvironmentStatus, according to the official advisory
Apache + mod_phpVulnerable. RCE was validated over HTTP, with default limits and prefork, before any application code runs. This is the most serious case.
PHP-FPMLess exposed for the out-of-memory case (109618): the child process exits when startup fails, and that advisory does not demonstrate a complete FPM exploit. In 109619, however, RCE through the session lifecycle was validated against FPM too, and there is a conditional path through PHP_VALUE.
FrankenPHPLikely susceptible, based on source-code analysis.
LSAPI / LiteSpeedConditional candidate, not yet validated.

On versions: the vulnerable code has existed since PHP 5.4 (2012), and Wiz and Sansec state that practically every version of the last decade is affected. The official advisories list branches 8.2 through 8.5 prior to the fixed releases as affected. There is no official patch for 8.1 and older, and Huntress reports that fixed source code (backports) exists for 7.4, 8.0 and 8.1.

On applications: Sansec reports confirmed unauthenticated RCE against Magento, WordPress, Drupal, Joomla, MediaWiki, Roundcube, phpMyAdmin, Nextcloud, Laravel, Symfony and WHMCS. The key point is that the flaw is in PHP, not in the application. Updating the plugin or the CMS does not fix it.

What is known about exploitation and public code

  • Update: 10/23: active exploitation is now confirmed by more sources (watchTowr, Patchstack, Cloudflare). See the threat analysis. The item below reflects what was known on 10/21.
  • Real attacks: Sansec cites early attacks reported by Cloudflare before the patch was released. Huntress said it was not seeing exploitation among its partners, but that other sources were reporting attacks. The prudent assumption is that mass exploitation is imminent.
  • Proof-of-concept (PoC) code: the official advisories link to none. Repositories of widely varying quality are circulating:
    • The 0x4148 lab and its accompanying analysis are transparent. They show the vulnerable path can be reached, but the author states they could not cause a crash or run code, because precise memory preparation (heap grooming) and build-specific addresses are missing.
    • Other repositories claim to have complete exploits, usually with no evidence, and some sell the code. Treat all of them as unverified.
  • Be careful what you download: PoC repositories for freshly disclosed flaws are a known malware vector against analysts. Do not run third-party code outside an isolated lab.
  • This does not make the risk acceptable: exploitation depends on memory state and a race condition, and a failed attempt usually crashes the worker. That creates noise (5xx errors and restarts), but the advisory is clear: multiple workers and process recycling lower the success rate of each attempt without removing the condition.

Update: 10/23 — CVE-2026-115560 and threat analysis

What changed

On October 23, 2026 (10:12 UTC), two days after the emergency fixes, PHP published the informational advisory “Session upload progress” and reserved CVE-2026-115560. What the advisory confirms:

  • It is a separate issue from PHP2Shell (109618 and 109619). It is not fixed in 8.5.12, 8.4.27, 8.3.36 and 8.2.35.
  • Conditions (all together):
    1. session.serialize_handler set to php_binary or php_serialize in configuration;
    2. the application switches the handler to php at runtime with ini_set() before session_start();
    3. session.upload_progress.enabled still on (the default).
  • Impact: possible remote code execution. PHP describes the combination as unusual and unlikely in practice.
  • Fix: coming in the next regular bugfix release, not an emergency one. The full advisory ships with it.
  • Official mitigation: session.upload_progress.enabled=0 until then. If you already applied it for CVE-2026-109619, nothing more is needed.

Not yet published: affected versions, fixed version, CVSS score, and whether the root cause matches 109619. Do not fill those gaps yourself. No exploitation of 115560 has been reported as of October 23: the attacks seen since October 21 target the two original CVEs.

There is also an independent claim (published by a researcher, no CVE) that a mismatch between the read and write values of session.serialize_handler allows object injection, reaching RCE through __wakeup() or __destruct(). It is unclear whether this is the same problem, since PHP names only php.ini plus ini_set(), while the claim also covers .htaccess and vhost settings. Treat it as unverified.

Threat intel analysis

This section is Gila’s assessment from public sources. Where something is our inference, we say so.

1. Exploitation of the original CVEs is confirmed. watchTowr observed exploitation of both CVEs in its honeypots on October 21. Patchstack reported “multiple active exploitation incidents” from hosting partners at 07:34 UTC, before the patch, and Cloudflare cited early attacks and deployed WAF rules. This corrects what we said earlier: Huntress initially saw no exploitation among its partners, but active exploitation is now documented by other sources. There is no attribution to any group, and no confirmed public payloads or IOCs.

2. The surface is huge and old. Recorded Future cites about 4.38 million exposed PHP services (Modat) and 5.1 million IPs running PHP (VirusTotal), mostly on branches already out of support. Those servers will not get an official fix. In our assessment, this unsupported estate is likely to account for most compromises over the coming weeks.

3. The exposure window began before the patch. The details leaked on October 20 and an archive with the material was submitted to VirusTotal on October 21 at 02:29 UTC. A compromise investigation should therefore look back to October 20 at the very least.

4. Public PoCs are unreliable, which does not help defenders. Recorded Future reports that two popular scripts rely on a theory the researcher later invalidated. That lowers the risk of trivial copying, but not the real risk: well-resourced attackers can build their own exploits, and the memory disclosure (credentials, tokens, TLS keys) is already useful to them without RCE. Our inference: expect more stable exploits in the coming weeks, especially against mod_php.

5. 115560 is low probability, not low care. It needs a specific combination, but the ini_set() condition can come from a library under vendor/, not only your own code. If you have many plugins and dependencies, do not assume you are out of scope. Since the mitigation has no meaningful cost, there is no reason to wait.

6. The most dangerous scenario is chaining. Memory disclosure to obtain secrets, then RCE or access with stolen credentials. Incident response must therefore include rotating secrets, not just updating PHP.

Update: 10/23. Scanner that “cannot validate” CVE-2026-115560. This result is expected and does not mean the system is unaffected. For now, PHP has not published the affected versions or the fixed version, so a version-matching scanner has nothing to compare against. There is also no public exploit or signature for an active test, and the condition depends on configuration and application code (including libraries under vendor/), which an external scan cannot see. Read “not validated” as “check on the host”: run the serialize_handler audit and confirm session.upload_progress.enabled = 0 on the process that serves the web. Anyone who already applied that setting can be treated as mitigated, regardless of version.

Workaround for CVE-2026-115560

Step 1: turn off upload progress at the right level. The 109619 advisory asks for the setting in php.ini, an FPM pool or server configuration, with all workers restarted. Do not rely on ini_set() or .user.ini.

; php.ini, PHP-FPM pool or server configuration
session.upload_progress.enabled = 0

Side effect: session-based upload progress bars stop working. Applications that do not use them see no difference.

Step 2: audit serialize_handler usage. Search configuration and code, including vendor/:

# PHP and web server configuration
grep -rIn "serialize_handler" /etc/php* /usr/local/etc/php /etc/apache2 /etc/nginx 2>/dev/null

# application code and dependencies
grep -rIn "serialize_handler" /var/www --include=*.php --include=.htaccess --include=.user.ini

If you find php_binary or php_serialize in configuration and an ini_set('session.serialize_handler', 'php') in code, that system meets the first two conditions. Prioritize the step 1 mitigation and monitoring for it.

Step 3: confirm it took effect. Check on the process that serves the web, not only the CLI:

# CLI (may not reflect the web server)
php -r 'var_dump(ini_get("session.upload_progress.enabled"));'

For the real web server value, use a temporary phpinfo() page restricted to your IP and remove it afterwards, or check the pool configuration. Never leave phpinfo() exposed.

Step 4: follow the fixed release. When PHP publishes the next regular release with the full 115560 advisory, update, and only then consider re-enabling the feature if you need it.

Consolidated workaround (all three CVEs)

LayerMeasureCovers
FixUpdate to 8.5.12, 8.4.27, 8.3.36 or 8.2.35 and restart workers109618 and 109619
Configurationsession.upload_progress.enabled = 0109619 (partial) and 115560
Web server/WAFBlock multipart/form-data where there is no upload and limit input size and nestingknown triggers of 109618 and 109619
ArchitectureIsolate or migrate PHP 8.1 and older; WAF or VPN in frontall, while no patch exists
DetectionAlert on shells spawned by php-fpm/httpd/apache2 and 5xx spikesattempts and post-exploitation
ResponseRotate secrets on suspect servers, with retroactive review from October 20memory disclosure

None of these measures replaces updating on its own.

Checklist changes

  • session.upload_progress.enabled = 0 applied in php.ini/pool/server (not via ini_set()), with all workers restarted.
  • serialize_handler audit done across configuration, application and vendor/.
  • Compromise investigation covering logs since October 20, 2026.
  • Update to the next regular PHP release scheduled.

How do you know whether you are exposed?

  1. Inventory everything that runs PHP, including what does not look like PHP: control panels, CMSs, bundled plugins, Docker images and shared hosting.
  2. Find out which PHP actually serves the web. The terminal’s php -v may point to a different installation.
# CLI version (may not be the web server's)
php -v

# PHP-FPM
php-fpm -v 2>/dev/null || php-fpm8.3 -v

# Apache with mod_php
apachectl -M 2>/dev/null | grep -i php

# container images
docker run --rm --entrypoint php YOUR_IMAGE:TAG -v
  1. Compare the version with the fixed ones: 8.5.12, 8.4.27, 8.3.36 and 8.2.35. Distribution packages (Debian, Ubuntu, RHEL) may carry the fix under a different version number. Check the vendor advisory.
  2. If you use the Remi repository, Sansec reported it did not have the fix yet on October 21. Check before assuming you are protected.

How do you fix it?

1. Update (the only complete fix)

Update to 8.5.12, 8.4.27, 8.3.36 or 8.2.35 and restart the workers (PHP-FPM reload, Apache restart). In containers, the version that counts is the one inside the image: rebuild on a base with a fixed PHP and redeploy. See the WordPress on Docker case study below.

Start with internet-facing systems, and among those with the ones using Apache with mod_php.

2. Unsupported versions (8.1 and older)

There is no official fix. In order of preference:

  1. migrate to a supported version;
  2. use a vendor with extended support (LTS);
  3. build from the source backports, keeping in mind that Huntress cannot verify third-party patches;
  4. meanwhile, isolate the system behind a VPN or WAF, or take it offline.

3. Temporary mitigations (reduce risk, do not solve it)

Turn off session upload progress. The advisory recommends doing this even after patching, if the feature is unused:

; php.ini of the SAPI that serves the web
session.upload_progress.enabled = 0

PHP 8.5 without the patch: this setting removes the source of the confirmed RCE, but not the other state families.

fatal_error_backtraces = 0

Block multipart/form-data where the application does not need it. Because PHP processes the request body before application code runs, the block must live in the web server or the WAF.

nginx:

# route that does NOT receive uploads
location / {
    if ($content_type ~* "^multipart/form-data") {
        return 403;
    }
    # ... normal fastcgi_pass / proxy
}
# allow multipart only where there is a legitimate upload
location = /upload {
    # ... normal configuration
}

Apache (mod_php):

SetEnvIfNoCase Content-Type "^multipart/form-data" is_multipart
<Location "/">
    <RequireAll>
        Require all granted
        Require not env is_multipart
    </RequireAll>
</Location>

We tested both rules in nginx:alpine and httpd:alpine containers: the syntax is valid, multipart is blocked with a 403 error and normal requests pass. Sansec recommends the same rule for nginx. Test on your own application as well, because product image uploads, contact forms and checkout often use multipart.

Limit of this mitigation: it covers the known multipart triggers, but advisory 109619 also describes situations that do not depend on multipart, such as INI diagnostics applied before initialization (for example via .htaccess or php_value on mod_php). It reduces the attack surface; it does not replace the update.

Limit the input at the proxy or WAF: decoded request size, a conservative post_max_size, a low max_input_nesting_level, and limits on the number of parts, headers per part and uploads.

memory_limit = -1. For installations that cannot update, advisory 109618 lists this as the main configuration mitigation, because it removes the predictable per-request limit that lets an attacker trigger the out-of-memory error in a controlled way. The advisory itself notes it is incomplete: if mmap() or another allocation fails, PHP can still use longjmp().

There is also a serious cost: a single request can consume all of the server’s memory, and Sansec advises restoring the limit after updating. If you choose this measure, restart every worker and confirm that no pool, directory or application setting restored a finite limit.

An external cgroup limit (memory.max) is an alternative, with a caveat: killing the container or cgroup can take down the master process and every worker, unless each worker has its own group.

Avoid RLIMIT_AS and RLIMIT_DATA. They make mmap() fail when the limit is reached and lead straight to the vulnerable path.

Other ways to reduce risk (from advisory 109619): eliminate fatal errors on paths the attacker can reach, reduce the INI diagnostics applied before initialization and, if performance allows, consider pm.max_requests = 1.

Case study: fixing a WordPress on Docker

To show the path in practice, here is a step-by-step of a real case we followed, with the names changed. It was a WordPress blog in docker-compose, with Apache and mod_php, and MariaDB in a separate container. The WordPress core was already up to date (7.1.3), but the container used the wordpress:latest image, with PHP 8.3.31, vulnerable to both CVEs. Because the flaw is in PHP, updating WordPress does not fix it.

1. Check the version inside the container

The version that matters is the container’s, not that of the server it runs on:

docker exec <container> php -v

2. See whether the official image already had the fix

On the day of disclosure (October 21), wordpress:latest and the php8.3-apache, php8.4-apache and php8.5-apache tags were still one version below the fix (8.3.35, 8.4.26 and 8.5.11). The official PHP image, php:8.3.36-apache, was already published. The solution was to build our own image.

This situation usually lasts only a few days. Before building your own image, check whether the official tag you use has already been updated.

3. Temporary mitigation

While the fixed image was not ready, we turned off upload progress with an .ini file mounted as a read-only volume:

; ./php-conf/99-php2shell-mitigation.ini
session.upload_progress.enabled = 0
# docker-compose.yml
services:
  wordpress:
    volumes:
      - ./html:/var/www/html
      - ./php-conf/99-php2shell-mitigation.ini:/usr/local/etc/php/conf.d/99-php2shell-mitigation.ini:ro

This reduces the attack surface but does not fix the flaw. The advisories are clear: only updating PHP solves it.

4. A custom image with PHP 8.3.36

We reproduced what the official WordPress image does (extensions, OPcache, error logging, remoteip and the entrypoint), changing only the base:

FROM wordpress:latest AS wp
FROM php:8.3.36-apache

RUN set -eux; \
    apt-get update; \
    apt-get install -y --no-install-recommends \
        ghostscript libfreetype6-dev libicu-dev libjpeg-dev \
        libmagickwand-dev libpng-dev libwebp-dev libzip-dev; \
    docker-php-ext-configure gd --with-freetype --with-jpeg --with-webp; \
    docker-php-ext-install -j"$(nproc)" bcmath exif gd intl mysqli zip; \
    pecl install imagick; \
    docker-php-ext-enable imagick opcache; \
    rm -rf /var/lib/apt/lists/* /tmp/pear

COPY --from=wp /usr/local/etc/php/conf.d/opcache-recommended.ini /usr/local/etc/php/conf.d/
COPY --from=wp /usr/local/etc/php/conf.d/error-logging.ini       /usr/local/etc/php/conf.d/
COPY --from=wp /etc/apache2/conf-available/remoteip.conf         /etc/apache2/conf-available/

RUN a2enmod rewrite expires remoteip && a2enconf remoteip && \
    chown www-data:www-data /var/www/html

COPY --from=wp /usr/src/wordpress /usr/src/wordpress
COPY --from=wp /usr/local/bin/docker-entrypoint.sh /usr/local/bin/

VOLUME /var/www/html
ENTRYPOINT ["docker-entrypoint.sh"]
CMD ["apache2-foreground"]
docker build -t mysite-wordpress:php8.3.36 .

If the build fails at pecl install imagick: the download comes from pecl.php.net, which can be unstable on high-demand days (on disclosure day, when reproducing this example, it answered with 500 and 504 errors). This does not mean the Dockerfile is wrong. Try again later, or leave imagick out if your site does not use it by removing libmagickwand-dev, the pecl line and imagick from docker-php-ext-enable.

5. Validate before switching

We compared php -m between the old and the new image. The module lists came out identical, which indicates that no extension WordPress uses was left behind.

6. Switch over

We backed up docker-compose.yml, replaced image: wordpress:latest with image: mysite-wordpress:php8.3.36 and ran docker compose up -d wordpress. The WordPress files (the ./html volume) and the database were not changed.

7. Verify

  • php -v in the container: 8.3.36.
  • /, /wp-login.php and /wp-json/ returned 200, /wp-admin/ returned 302 (redirect to login) and the public site returned 200.
  • session.upload_progress.enabled confirmed as 0.
  • Way back: restore the backed-up docker-compose.yml and bring the container up again.

Trade-offs and points of attention

  • No automatic updates. A custom image does not receive the official image’s updates. Once the official WordPress image ships with PHP 8.3.36 or higher, it is worth going back to it.
  • Multipart was not blocked, so as not to break WordPress media uploads.
  • memory_limit = -1 was not used, because it lets a single request consume all of the server’s memory.
  • Scope of validation. We confirmed the site responds. We did not test media upload or password login, and those belong in your test script.
  • No indicators of compromise. We found no known PHP2Shell IOCs, and the absence of signs in the logs does not prove there was no exploitation.

How do you detect attempts and compromise?

The advisories warn: a clean log does not prove everything is fine. There are also no confirmed indicators of compromise (IOCs), and multipart/form-data and PHP_SESSION_UPLOAD_PROGRESS alone are not useful indicators, because they are legitimate uses.

Signs of an attempt:

  • multipart requests on routes that do not receive uploads;
  • memory-limit errors right after multipart requests;
  • spikes of 5xx errors from PHP workers (Upwind treats them as a high-confidence signal of a failed attempt) and frequent worker restarts;
  • unusually large or malformed PHPSESSID cookies in responses, which may indicate memory disclosure.

Post-exploitation signs (look in process telemetry or your EDR):

  • php-fpm, php-cgi, httpd or apache2 spawning processes such as sh, bash, python, perl, curl, wget or nc;
  • arguments containing /dev/tcp/, fsockopen or mkfifo;
  • reconnaissance commands such as whoami, id and uname -a run by the web server user;
  • new files in the web directory, cron jobs and user accounts nobody created.

To make investigation easier, enable log_errors, a working error_log and error_reporting=E_ALL in the startup configuration.

What if you suspect a compromise?

  1. Isolate the server from the network.
  2. Preserve the web server and PHP logs and a disk image before changing anything.
  3. Look for webshells, recent files in the web directory, cron, scheduled tasks and new accounts.
  4. Rotate the credentials and secrets the process could reach: API keys, database passwords, session tokens and TLS keys. The memory disclosure may have exposed them.
  5. Update PHP before putting the system back online and rebuild the server from a known, trusted image.
  6. If personal data was accessed, assess the notification obligations under privacy law (LGPD/GDPR).

Quick checklist

  • Inventory of every system running PHP, including containers and third-party software.
  • PHP version checked inside each container (docker exec <container> php -v), not just on the host.
  • SAPI serving the web identified on each one (mod_php, FPM, FrankenPHP).
  • Updated to 8.5.12, 8.4.27, 8.3.36 or 8.2.35, with workers restarted.
  • Systems on PHP 8.1 or older isolated or migrated.
  • session.upload_progress.enabled = 0 applied where the feature is unused.
  • Multipart blocked on routes without uploads, and the rule tested.
  • Alerts for workers spawning shells and for 5xx spikes.
  • Secrets rotated on any server under suspicion.

Where Gila and Defenzor come in

A flaw in the language core is the worst case for a company, because it is in everything that runs PHP, including what nobody remembers exists. The first step is knowing what you have exposed. Defenzor continuously monitors your digital surface, helps identify exposed technologies and versions, and alerts you when something changes, with notifications in Slack, Teams or by webhook.

Update: 10/23. From finding to fix. With three CVEs in play, the challenge shifts from discovering to prioritizing and tracking remediation. Defenzor’s vulnerability management (page in Portuguese) ranks findings by real-world exploitation, using the CISA KEV list and EPSS, and lets you filter for only what is under active exploitation, which is the case for PHP2Shell. Findings that share a root cause (such as “outdated PHP” across many servers) become a remediation plan with an owner and due dates, and each finding moves through Open, In progress, Fixed, Re-test and Closed. That way, the PHP update and the CVE-2026-115560 mitigation are tracked through validation, with an audit trail.

To confirm the fix was applied and whether any server was already attacked, Gila runs penetration tests and compromise assessments, with reproducible evidence and prioritized recommendations.

Want help mapping and fixing your PHP2Shell exposure? Talk to Gila Security.

References