Knowledge Base · Updated: 25 October 2026 · WebPot DEV

PHP2Shell: how to fix the critical PHP vulnerability on web hosting and VPS

Official PHP logo on a dark background, with a shield below and the patched PHP versions: 8.5.12, 8.4.27, 8.3.36, 8.2.35

The short answer: On 21 October 2026, PHP developers fixed two critical vulnerabilities (CVE-2026-109618 and CVE-2026-109619, CVSS 9.2), allowing unauthenticated PHP remote code execution on almost any web PHP installation with a crafted request. There is only one real fix: updating PHP to version 8.5.12, 8.4.27, 8.3.36, or 8.2.35 (or your distribution's patched package), then restarting PHP processes. On shared hosting, your provider handles this, but you must verify. On a VPS, it is your responsibility. On our own servers, the patched PHP was running seven hours after the official release.

Where your site runsWhat to doWho does it
Shared hosting (cPanel, Plesk, DirectAdmin)Check the PHP version and request written confirmation from your providerThe provider updates, you verify
Managed WordPress hostingCheck the provider's announcement, usually no action requiredThe provider
Own VPS (Ubuntu, Debian, AlmaLinux)Package update, restart PHP-FPM and Apache, review logsYou or your administrator
Docker containerRebuild image from updated base image, replace containersThe developer or administrator
PHP 8.1 or olderSwitch to 8.3 or 8.4, until done, provider's backported packageJointly: testing required before switching

What is PHP2Shell and why is it so dangerous?

PHP2Shell is the collective name for two related vulnerabilities in the PHP interpreter itself, not in a plugin or a framework. Both follow the same pattern: if the processing of a request is interrupted halfway through (running out of memory or encountering a fatal error), PHP later considers an incomplete internal state to be valid. An attacker can populate this incomplete state with their own data, and the cleanup process ultimately executes their command.

  • CVE-2026-109618. If PHP runs out of memory while processing form data, an entry counter is updated, but the entry itself is not created. The cleanup at the end of the request treats this garbage as a real PHP value.
  • CVE-2026-109619. A PHP process serves many requests sequentially. After an interrupted request, a pointer pointing to already freed memory may remain in the process. The next request continues to use it (known as use-after-free). According to PHP's official description, memory contents can also be read this way, including data from other requests.
Flowchart: a POST request, memory exhaustion, an incomplete entry, and command execution, all within the PHP interpreter before application launchFlowchart: a POST request, memory exhaustion, an incomplete entry, and command execution, all within the PHP interpreter before application launch
The CVE-2026-109618 attack chain simplified. CVE-2026-109619 arrives at the same outcome via a different path through memory freed after a previous request.

Why doesn't a WordPress update or security plugin protect you?

Because PHP processes the attacker's request before the very first line of application code is executed. The vulnerability arises when parsing the POST request body, so it does not matter whether WordPress, Magento, Drupal, or custom software is running on the server: access to any PHP file is sufficient, even a simple contact page. Login protection, CAPTCHA, and security plugins have not even started at this point.

Important: a successful attack does not necessarily trigger an error message or crash. A HTTP 200 response in the logs proves nothing; the request could still have been malicious.

Who is affected: versions and execution modes

Every PHP installation serving web requests: PHP-FPM, Apache mod_php, php-cgi, FrankenPHP, and LiteSpeed. According to the PHP team, mod_php poses the highest risk. Command-line PHP (CLI, cron) cannot be attacked externally this way, but is updated from the same package.

PHP branchPatched versionNotes
8.58.5.12Fatal error stack tracing is also an attack vector here (see temporary mitigation)
8.48.4.27Supported branch, recommended to upgrade here from older versions
8.38.3.36Receives security fixes only
8.28.2.35Reaches end of life on 31 December 2026, no further patches afterwards
7.4–8.1No official releaseThe PHP team published a minimal source patch; distributions and providers build packages from this
5.4–7.3No patchAccording to researchers, the vulnerable code has existed since PHP 5.4; these branches can only be replaced

Linux distributions (Ubuntu, Debian, Red Hat) and CloudLinux often release the fix backported without changing the version number. In such cases, a version number that appears older may already be patched, so the package changelog is authoritative.

What happened between 17 and 23 October?

17 OctoberFirst attempt

Amazon's honeypot network detected exploitation attempts four days before public disclosure. Amazon recommends starting log reviews from this date, rather than the release day.

20 OctoberLeak

The vulnerability identifiers surfaced on social media. PHP announced a security release for the next day, bringing it forward by one day from the original plan. CERT-EU issued a separate warning.

21 October, 16:00Patched releases

Versions 8.5.12, 8.4.27, 8.3.36, and 8.2.35 were released, along with source code patches for the 7.4, 8.0, and 8.1 branches. That day, Cloudflare reported early attacks and deployed protection rules for everyone, including free plan users. US CISA requested immediate updates.

22–23 OctoberMass scanning

Multiple security firms confirmed widespread, untargeted scanning and publicly circulating exploit codes. Some of these may themselves contain malware, making testing inadvisable.

23 OctoberThird, minor flaw

PHP published another advisory (CVE-2026-115560). This is only dangerous in rare configurations, but the recommended action is simple for everyone, so we describe it separately.

Timeline of 21 October 2026 in Hungarian time: 04:29 leak, 09:34 attacks at hosting providers, 11:45 Finnish outage, 16:00 patch release, 22:58 our server updatedTimeline of 21 October 2026 in Hungarian time: 04:29 leak, 09:34 attacks at hosting providers, 11:45 Finnish outage, 16:00 patch release, 22:58 our server updated
The critical day hour by hour, in Hungarian time. Timestamps are sourced from Recorded Future, Sansec, Helsinki Times, and php.net announcements; the 22:58 entry comes from our own server log.

The third vulnerability: CVE-2026-115560

This flaw can be exploited if the application sets session.serialize_handler in the configuration to php_binary or php_serialize, or switches it at runtime using ini_set() to php, while session upload progress is enabled. According to PHP, this scenario is unlikely. The patch will arrive in the next regular release; until then, PHP recommends ensuring session.upload_progress.enabled is disabled. Most sites do not use this feature, so disabling it breaks nothing.

Who was affected by the attack, and how?

The greatest visible damage caused by PHP2Shell stemmed not from actual breaches, but from precautionary shutdowns. According to public sources, no major organisation had reported a confirmed intrusion by 25 October. However, several governments and major service providers chose to take their PHP-based sites offline until the patch was released and applied.

WhoWhat happenedNotes
HungaryAs a precaution, magyarorszag.hu and several other government websites were taken offline. According to the announcement, administration via the portal was expected to be suspended for 48 hours.According to the government, no signs of an attack were found. The National Cyber Security Institute (NKI) issued a critical alert on 21 October.
NetherlandsFollowing the CERT-EU warning, the Dutch National Cyber Security Centre (NCSC) recommended taking PHP sites offline. Affected sites included DigiD, MijnOverheid, Overheid.nl, the parliamentary website, the RTL news portal, and Tweakers.DigiD and MijnOverheid returned online after patching. The shutdowns led to parliamentary questions.
FinlandThe government IT centre (Valtori) restricted public traffic to government sites at 12:45 local time. Sites and services affected or disrupted included the National Land Survey of Finland, several Yle services, and University of Helsinki systems.Valtori stated this was a preventive measure rather than a response to a confirmed attack. The internal government network operated without disruption.
France, Belgium, DenmarkWebsites of the French Ministry of the Interior, Belgian government websites, and Denmark's national school communication platform went offline.Precautionary measure; no confirmed attacks reported.
WikimediaSeveral backend systems were taken offline, making parts of Wikipedia temporarily unavailable.MediaWiki, the software powering Wikipedia, is also written in PHP.
BBC, Internet Archive, 4chan, DeviantArtCertain sites and services became temporarily unavailable or switched to read-only mode while the patch was applied.Sources reported service disruptions, not data theft.

Estimates of exposure vary widely: Palo Alto Networks observed 22.6 million potentially vulnerable instances, an independent researcher counted 1.3 million, and a Shodan-based scan estimated 1.9 million internet-facing PHP machines. The discrepancy stems from different measurement methodologies. According to W3Techs, 69 per cent of websites with a known server-side programming language run on PHP.

How was exploitation attempted?

  • Honeypots and scanning. Amazon recorded attempts on its honeypots as early as 17 October, while watchTowr and other security firms detected activity from 21 October. On the morning of 21 October, Cloudflare flagged early attacks prior to the patch release.
  • Hosting providers. On the morning of 21 October, Patchstack reported that its hosting partners observed multiple active exploitation incidents. The providers were not named.
  • Leaked and fake exploit codes. Descriptions of the vulnerabilities appeared on VirusTotal prior to the patch release. The PHP security team found no working proof-of-concept (PoC) exploits among those circulating at the time of release. Security firms noted that some of these sample codes may themselves contain malware.
  • Why has it not led to mass breaches (so far)? According to Sansec, there is no single request that works across all servers like Log4Shell did; an attacker must know the target server's configuration. Most public exploit codes do not work on a default PHP setup, and many require an additional local file inclusion (LFI) vulnerability. Rapid7 noted that every demonstrated attack worked only on a specific combination of operating system, PHP version, and web server. However, VulnCheck built a working exploit for standard production PHP 8.4 configurations, though it released it only to its customers. An unpatched server therefore remains defenseless against a determined attacker.

What is at risk if compromised?

  • Code execution as the web server. An attacker can install a webshell or malware, access files and databases, and pivot to other internal systems from there.
  • Leaked secrets. Via the memory disclosure vector, Sansec notes that passwords, session IDs, API keys, and even TLS private keys could be exposed, even if the application itself does not use sessions. If a server remained unpatched and accessible for days, rotating keys and passwords is strongly advisable.
  • Downtime. Taking systems offline is damage in itself: in Hungary and the Netherlands, online public administration was suspended. This is why being able to update a server in hours rather than days is critical.

Fixing it on shared hosting

On shared hosting, PHP is installed and updated by the provider and you have no access to the server. Your job is therefore to verify: you need to know that the fix has actually been applied.

  1. Check the PHP version. In cPanel, look at “Select PHP Version” or the MultiPHP Manager; in Plesk, the domain's “PHP Settings” page shows it. In WordPress: Tools › Site Health › Info › Server.
  2. Do not rely on the number alone. If it is 8.5.12, 8.4.27, 8.3.36, 8.2.35 or later, you are fine. If it is lower, it may still be patched (the provider may have backported the fix), but only the provider can confirm that.
  3. Ask for a written answer. You can send the email below to customer support as it is.
  4. Switch if you are on PHP 8.1 or older. Take a backup, try it on a staging site if you can, then set the version to 8.3 or 8.4 in the control panel. Old themes and plugins may break on a newer PHP, so afterwards check your important pages, and the checkout if you run an online store.
  5. If the site is behind Cloudflare, Cloudflare has rolled out its PHP2Shell rules on the free plan too. On Pro or higher plans, make sure the managed rules block rather than only log. This is an additional layer, not a fix: the filter can be bypassed through the server's direct IP address.
Sample email to your hosting provider

Subject: PHP security update (CVE-2026-109618, CVE-2026-109619)

Dear Support Team, which PHP version is running on the hosting account for [domain]? Have you installed the PHP security release of 21 October 2026 (CVE-2026-109618, CVE-2026-109619)? If the fix was applied without a change in the version number, please confirm in writing which package build contains it. Thank you.

What does not help on shared hosting: updating WordPress, the theme or the plugins (a good thing to do, but it does not fix this flaw), installing a security plugin, or disabling session.upload_progress.enabled in a .user.ini file or with ini_set(). According to the PHP advisory, these settings take effect too late: by then the attacker's request has already been processed.

Fixing it on a VPS and in containers

On your own server the whole chain is yours: updating the package, replacing the running processes and verifying the result. Skipping the restart is the most common mistake: the patched PHP is already on disk, but the old one is still running in memory.

Ubuntu and Debian

First find out which PHP serves the web. php -v only shows the command-line build; websites often run on a different branch.

# Which PHP-FPM branches are running? (the socket name tells you)
ls /run/php/
php-fpm8.3 -v

# Update (from the ondrej/sury repository and from the Ubuntu or Debian security repository alike)
sudo apt update
apt list --upgradable 2>/dev/null | grep php
sudo apt upgrade

# Restart: every running PHP branch and Apache (if you use mod_php)
sudo systemctl restart php8.3-fpm
sudo systemctl restart apache2

# Verify: the version and the start time (it must be after the update)
php-fpm8.3 -v
systemctl show -p ActiveEnterTimestamp php8.3-fpm

If you use the distribution's own PHP package (Ubuntu 24.04, for example, ships 8.3 by default), the version number does not jump to 8.3.36; the fix arrives as a backport. In that case, look for the CVE number in the package changelog:

zgrep -c "CVE-2026-109618" /usr/share/doc/php8.3-common/changelog.Debian.gz

If the result is 0, the fix is not installed yet: check whether the security repository is enabled, or wait for the distribution's announcement.

AlmaLinux, Rocky Linux, RHEL

sudo dnf upgrade 'php*'
sudo systemctl restart php-fpm httpd
php-fpm -v

With the Remi repository the procedure is the same, using package and service names such as php83-php-fpm.

Docker and containers

PHP running in a container is not updated together with the host. The image has to be rebuilt from a fresh base image and the old containers replaced. If the Dockerfile pins an exact version (for example php:8.3.35-fpm), change that too.

docker compose build --pull
docker compose up -d
docker compose exec app php -v   # replace “app” with the name of your own service

If you cannot update today: temporary mitigation

The PHP team recommends a few settings for the period until the update can be scheduled. These reduce the risk but do not eliminate it. They go into php.ini or the PHP-FPM pool file, and every PHP process must be restarted afterwards.

; php.ini (.user.ini and ini_set() have no effect here)
session.upload_progress.enabled = 0
fatal_error_backtraces = 0        ; PHP 8.5 only
post_max_size = 8M                ; 32M if the site has file uploads
upload_max_filesize = 6M          ; always smaller than post_max_size

; PHP-FPM pool, for example /etc/php/8.3/fpm/pool.d/www.conf
php_admin_value[memory_limit] = -1

memory_limit = -1 removes the trigger of CVE-2026-109618 (hitting the memory limit), but in exchange a single request can consume the server's entire memory. Apply it only if the memory of the PHP processes is limited by something else as well (a container or cgroup limit) and the web server also filters request sizes (client_max_body_size in nginx). CERT-EU recommends temporarily taking anything that cannot be updated off the public internet, while CISA would have systems on PHP 8.1 and older switched off until they are patched.

Have you been hacked? How to check

The update rules out future attacks, not past ones. Since the first attempt took place on 17 October, it is worth reviewing the logs from that day onwards. Each sign may be harmless on its own, but together they are suspicious.

  • Memory error at request start-up: an “Allowed memory size … exhausted” error that reports “Unknown on line 0” instead of your code, especially in series, within one process.
  • Crashing PHP processes: SIGSEGV (signal 11) in the PHP-FPM log.
  • Unusual requests: large, chunked POST requests with many or deeply nested form fields, and a long or binary PHPSESSID cookie.
  • A shell running as the web server: if the www-data user runs sh, bash, curl or wget, that is the strongest sign.
  • New PHP files in upload and cache folders, where there should be no PHP at all.
# Memory error at request start-up
sudo zgrep -h "Allowed memory size" /var/log/php*-fpm.log* /var/log/nginx/error.log* | grep -c "Unknown on line 0"

# Crashing PHP processes
sudo zgrep -h "SIGSEGV" /var/log/php*-fpm.log*

# Is the web server user running a shell or a downloader?
ps -u www-data -o pid,lstart,cmd | grep -E "sh -c|bash|curl|wget"

# PHP files created in upload folders since 17 October
sudo find /var/www -path "*upload*" -name "*.php" -newermt 2026-10-17

If any of these returns a suspicious hit, do not clean up straight away, because you would destroy the evidence along with the traces. Save the logs, replace every password and key (database, email, payment and API keys), and restore the site from a clean backup taken before 17 October. It is worth calling in a specialist for this.

How did we get through it?

Our own WebPotCMS sites and those of our clients run on an Ubuntu LTS server that we operate ourselves: thirty-one nginx sites including staging environments and admin interfaces, with Cloudflare in front and PHP-FPM 8.5 and 8.3 behind. The times below are not estimates; they come from the server's package manager and service logs, in Hungarian time (CEST).

7 hoursfrom the official release to the patched PHP going live
18 secto restart both PHP-FPM services and Apache
0crashes or attack-related memory errors since 17 October
21 October, 16:00The fix is released

PHP releases 8.5.12 and 8.3.36. Our server gets PHP from the ondrej/sury repository, where the patched packages became available the same day.

21 October, 22:58Update

All three installed PHP branches received the patched package: 8.5 and 8.3, which serve the websites, and 8.1, which we now use only for command-line tasks.

21 October, 23:00Restart

Between 23:00:19 and 23:00:37 the two PHP-FPM services and Apache were restarted. From then on, no old PHP was running in memory either. The package log and the service start times show the same thing, so this is a verified fact, not an assumption.

21 OctoberAutomatic updates

We added the PHP package repository to the automatic security updates. The next fix of this kind will be installed on its own and will not depend on who happens to be free that evening.

22 October, morningClean-up

We removed the old PHP 8.0 packages that were no longer in use. What is not installed does not need updating and cannot be attacked.

22 OctoberAudit

We brought forward the server's full security and performance audit: logins, logs, certificates, running services. We upgraded an outdated internal tool to its latest release and retuned the memory allocation so that free memory grew from 2.6 GB to 6.5 GB. With an attack built on memory exhaustion, a reserve does no harm.

25 OctoberRetrospective check

We reviewed the PHP-FPM logs back to 2 August and the nginx error logs back to 16 August. The last PHP crash (SIGSEGV) dates from 15 September and there has been none since 17 October, while the “Unknown on line 0” memory error at request start-up did not occur once in the whole period. The server's own intrusion checker found no traces either: no webshell pattern, hidden process, SUID file outside a package or suspicious outbound connection, and not a single file in the version-controlled production code differs from the repository.

Terminal excerpt from the server logs: PHP packages updated between 22:57 and 22:58, PHP-FPM and Apache restarted at 23:00, the last PHP crash on 15 SeptemberTerminal excerpt from the server logs: PHP packages updated between 22:57 and 22:58, PHP-FPM and Apache restarted at 23:00, the last PHP crash on 15 September
Excerpt from the package, service and PHP-FPM logs, queried on 25 October. We shortened the host name, the system prefixes and the long suffix of the package versions; the times are unchanged.

Why was there no need to panic?

The quick update was the decisive step, but not the only one. Even before the update, several layers stood in front of PHP on the server. They pay for themselves precisely with a flaw like this one, exploitable before login.

Diagram of the defence layers: on a public site Cloudflare, nginx and the patched PHP-FPM, on an admin interface nginx basic auth stops the request, with fail2ban alongsideDiagram of the defence layers: on a public site Cloudflare, nginx and the patched PHP-FPM, on an admin interface nginx basic auth stops the request, with fail2ban alongside
Simplified diagram based on the real configuration of our server: where a PHP2Shell request gets stuck on public sites and on admin interfaces.
  • nginx basic auth on admin interfaces. Administration tools and staging sites are protected by a password that nginx asks for before the request ever reaches PHP. Without the password, the attacker's POST request never gets to the vulnerable code. The riskiest way of running PHP, Apache mod_php, only runs behind such internal tools on our server, and the firewall does not allow access to its port from outside.
  • nginx stands in front of every PHP. The PHP processes cannot be reached directly from outside, and nginx limits the size of requests before PHP sees them at all.
  • Cloudflare in front of public sites. On 21 October Cloudflare rolled out its PHP2Shell rules, so the traffic of our public sites passed through this filter too. We did not rely on it, because it is a filter, not a fix.
  • fail2ban with seven jails. SSH, mail and two nginx jails are running: one bans bots scanning for vulnerabilities, the other bans basic auth password guessers, both on the server firewall and on Cloudflare at the same time. A ban lasts one day, longer on each repeat, up to one week. fail2ban does not stop a single, well-targeted request, but it significantly reduces the noise of mass scanning: since 22 October the SSH jail alone has banned nearly six hundred addresses.

What we learned from this

  1. A quick manual update is not a plan. We had time that evening; another time we might not. That is why the PHP repository was added to the automatic updates.
  2. An update is only worth anything together with a restart. We did not assume that the services had really restarted; we verified it by comparing the package log with the start times.
  3. Unused software is a risk too. Every old PHP branch, forgotten admin interface and staging site is one more place that needs updating.
  4. Password pre-filtering is cheap and it works. What is not meant for the public should not be public: one basic auth line in nginx fends off even a pre-login flaw.

Prevention for the next flaw

PHP2Shell will not be the last flaw of its kind. According to the researchers it is a bug pattern, not a single slip. What is more, a growing number of teams are hunting for such flaws with artificial intelligence. So the goal is not to guess the next one, but to be able to close it within hours when it comes.

Automatic security updates, including the PHP repository

On Ubuntu, unattended-upgrades only updates the distribution's security repository by default. If PHP comes from a separate repository (for example ondrej/php), it has to be added separately, otherwise PHP is left out.

// /etc/apt/apt.conf.d/50unattended-upgrades
Unattended-Upgrade::Allowed-Origins {
    "${distro_id}:${distro_codename}-security";
    "LP-PPA-ondrej-php:${distro_codename}";
};

It is worth installing the needrestart package alongside it: after an update it lists, and depending on its settings also restarts, the services that are still using the old libraries.

Put anything that is not public behind a password or IP filter

Database manager, mail admin, staging site, development copy: none of these is meant for visitors. nginx basic auth at the level of the server block protects every path, including the one leading to PHP.

# create the password file (apache2-utils package)
sudo htpasswd -c /etc/nginx/.htpasswd admin
sudo chown root:www-data /etc/nginx/.htpasswd
sudo chmod 640 /etc/nginx/.htpasswd

# /etc/nginx/sites-available/admin.example.com.conf
server {
    server_name admin.example.com;
    auth_basic           "Login required";
    auth_basic_user_file /etc/nginx/.htpasswd;
    # IP filtering instead or in addition:
    # allow 203.0.113.10;
    # deny  all;
    ...
}

Behind Cloudflare, nginx has to see the visitor's real address for IP filtering (real_ip_header CF-Connecting-IP), otherwise it filters Cloudflare's addresses. A more convenient, logged alternative is Cloudflare Access or a VPN.

fail2ban for nginx too, not just SSH

On most installations fail2ban only watches SSH. Enabling two nginx jails takes a few lines. They ban basic auth guessers as well as bots scanning for vulnerabilities.

# /etc/fail2ban/jail.local
[DEFAULT]
bantime           = 1d
bantime.increment = true
bantime.maxtime   = 1w

[nginx-http-auth]
enabled = true

[nginx-botsearch]
enabled = true

Behind Cloudflare, an IP address banned on the firewall achieves nothing, because the request arrives from Cloudflare's address. In that case fail2ban can also ban through the Cloudflare API (the built-in cloudflare action); we ban in both places.

The other layers in brief

  • A supported PHP branch. 8.2 reaches end of life on 31 December 2026. If you are updating now, move straight to 8.4 or 8.5, so that at the next flaw you are not struggling with a version change.
  • Request size and memory limits. In nginx, set client_max_body_size per site to just what is needed, and cap the memory of the PHP processes from above (FPM pool, container, cgroup).
  • Isolation. A separate PHP-FPM pool and system user per site, with open_basedir set. Even if one site falls, it should not take the others with it.
  • Alerting. A notification when a crash appears in the PHP-FPM log, or when the web server user starts a shell.
  • Off-site backups, with a tested restore. After a breach, this decides whether the site is back in hours or days.

If you do not have your own system administrator, we can carry out these steps as part of our managed VPS service, and for WordPress sites they are part of our WordPress maintenance.

Frequently asked questions about the PHP2Shell flaw

Yes, if the PHP running on the server has not yet received the 21 October fix. The flaw is in PHP, not in WordPress, so updating WordPress, the theme and the plugins does not fix it. On shared hosting the provider has to update and you have to verify.
According to public sources, no major organisation had reported a confirmed breach by 25 October. Most of those affected shut down as a precaution until the fix was installed, including Hungary's magyarorszag.hu, the Dutch DigiD and MijnOverheid, the Finnish government sites and some Wikimedia systems.
If the version is 8.5.12, 8.4.27, 8.3.36, 8.2.35 or later, the fix is installed. A lower version number may also be patched if the provider has backported the fix, but only the provider can confirm that. Ask in writing.
No. It only closes one attack path of CVE-2026-109619 and does not protect against CVE-2026-109618. It is fine as a temporary mitigation, but only updating PHP fixes the flaw.
Not the machine, but you do need to restart the PHP-FPM service, and Apache too if you use mod_php. Until that happens, the old, vulnerable PHP keeps running in memory. With containers, the image has to be rebuilt and the container replaced.
It reduces the risk but does not fix anything. It only filters the traffic that passes through it and can be bypassed through the server's direct IP address. What is more, the rules cannot see into every type of request, such as chunked requests.
Not against a single well-targeted request, because fail2ban bans on repeated patterns. It slows down mass scanning and bans password guessers, so it is useful as an additional layer.
These branches do not receive an official release. In the short term, a patched package from the provider or the distribution helps; in the long term, switch to 8.3 or 8.4. If neither is feasible, CISA recommends keeping the system unreachable from the internet until it is patched.
A lower-risk PHP flaw published on 23 October that can only be exploited with a rare session configuration. The fix will arrive in the next regular release; until then PHP recommends disabling session.upload_progress.enabled in php.ini or in the PHP-FPM pool file.

Not sure whether your server or hosting is already patched?We review the PHP version, the running services and the logs, then tell you what needs to be done.

Request a check

Related pagesManaged Ubuntu VPS server, What is a VPS server used for?, WordPress maintenance prices.

Sources (retrieved: 25 October 2026)PHP: official security announcements (20, 21 and 23 October) · Datadog Security Labs: analysis and detection of the flaw · Tenable: FAQ and timeline · Palo Alto Unit 42: threat brief · Recorded Future: exploitation timeline · Sansec: online stores and the chance of mass exploitation · Origo: magyarorszag.hu shut down (in Hungarian) · NOS: Dutch government sites offline (in Dutch) · Helsinki Times: Finnish government shutdown

ImagesThe cover image shows the official PHP logo, unmodified: Colin Viebrock, CC BY-SA 4.0, source: php.net. This article is not an official statement by the PHP team. The diagrams were made by WebPot DEV.

Back to topShare page

#PHP #Security #VPS #WordPress