PHP’s maintainers issued an advisory on Wednesday, 18 November, announcing a security release that fixes critical flaws in every supported version of the language. The releases are scheduled for Thursday, 19 November 2026, between 14:00 and 14:30 UTC. The project’s own wording leaves little ambiguity: “These releases are part of PHP’s regular four-week release cycle and will address security vulnerabilities affecting all supported PHP versions. The highest severity is CRITICAL.”
Coming barely a month after the emergency PHP2Shell patches consumed a week of collective effort across the PHP ecosystem, that sentence would have caused real dread in October. This time the advisory adds a qualifier: “The issues rated CRITICAL require either non-default configuration or uncommon setups.” No further specifics were disclosed. What is already public, together with a month of exploitation against the October flaws, gives a fairly precise picture of what Thursday’s release will contain and why you should check your own configuration before trusting that qualifier.
PHP security release at a glance
- Release window: Thursday, 19 November 2026, 14:00 to 14:30 UTC.
- Affected branches: every supported version, which means PHP 8.2 through 8.5.
- Severity: the highest rating is CRITICAL, but the critical issues need non-default configuration or uncommon setups.
- Known issue: CVE-2026-115560, a remote code execution vector in session upload progress, with a one-setting mitigation available today.
- Same-day release: PHP 8.6.0 is planned for general availability on 19 November.
- Deadline: PHP 8.2 reaches end of life on 31 December 2026.
What PHP’s November 2026 security advisory says (and what it holds back)
The announcement on php.net is deliberately sparse. It confirms the release window, the four-week-cycle context, the CRITICAL ceiling, and the configuration-dependent nature of the worst issues. It closes by urging users to “prepare to upgrade promptly once the releases become available,” with technical details and fixed version numbers to be published alongside the releases themselves. The full CVE list is not out. Neither are the individual severity scores or the affected-version ranges.
PHP runs on roughly 70 percent of websites with a known server-side language, per W3Techs figures cited during the October incident, so an announcement this thin would normally be frustrating. Here the thinness is procedural. The project is following its coordinated disclosure process, and the one vulnerability it has already described publicly was handled the same way in October.
CVE-2026-115560 is expected in Thursday’s batch
That vulnerability is CVE-2026-115560, a remote code execution vector in PHP’s session upload progress machinery. PHP published an informational advisory for it on 23 October, two days after the PHP2Shell emergency releases, and explicitly declined to issue another out-of-band patch. Elizabeth Barron, executive director of the PHP Foundation, told The Register that the flaw “requires a very unlikely combination of configuration and specific PHP application code, which we do not expect to occur in practical use of PHP.” Because a single configuration setting mitigates it, she said, the security team saw no justification for repeating October’s scramble. The full advisory was promised with the next regular bugfix release, and the 19 November releases are that release.
Three facts frame the interim risk. The October releases that fixed PHP2Shell (8.5.12, 8.4.27, 8.3.36, and 8.2.35) do not contain a fix for this issue. PHP has published no CVSS score or affected-version list for it. And no exploitation of CVE-2026-115560 has been reported.

PHP 8.6.0 ships the same day, and PHP 8.2 is nearly out of support
Two calendar details make Thursday more consequential than a routine patch slot. The same day is the planned general availability of PHP 8.6.0, according to the project’s RC7 announcement, so release managers will ship a new minor version and a critical security batch within hours of each other.
The October announcement for PHP 8.2.35 also carried a reminder that PHP 8.2 reaches end of life on 31 December 2026. The supported branches covered by this advisory are 8.2 through 8.5, and for the oldest of them this is one of the last regular cycles that provides security coverage at all. Teams still on 8.2 should read Thursday’s release as a patch and a deadline notice.
How CVE-2026-115560 works: session serialization meets upload progress
Understanding why this flaw exists requires a look at a corner of PHP most applications never touch deliberately.
PHP session serialize handlers: php, php_binary, and php_serialize
The session.serialize_handler directive selects the on-disk format PHP uses when it writes $_SESSION to storage and reads it back. Three built-in handlers exist.
📬 Stay Ahead of Cyber Threats
Get the latest cybersecurity news, critical vulnerabilities, threat intelligence, tutorials, and exclusive giveaways delivered straight to your inbox. No spam. Unsubscribe anytime.
The default, php, writes each top-level key, a pipe character as separator, then the serialized value, so $_SESSION['user_id'] = 42 becomes the byte string user_id|i:42;. The older php_binary format replaces the separator with a length marker: one byte holding the key’s length, the key itself, then the serialized value. The php_serialize handler, introduced in PHP 5.5.4, drops per-key structure and runs serialize() on the entire array, producing something like a:1:{s:7:"user_id";i:42;}.
The manual documents the older formats’ limits: they cannot store numeric keys, or string keys containing the | or ! characters. That restriction shows the property that matters here. In the php format, a pipe is structure. In the other two formats, a pipe inside a string is data. Bytes written by one handler and parsed by another can mean something quite different from what was written.
Session upload progress and attacker-controlled session keys
The second ingredient is session upload progress, a feature present since PHP 5.4 that lets a browser poll the status of a file upload. When a multipart/form-data POST contains a field whose name matches session.upload_progress.name (by default PHP_SESSION_UPLOAD_PROGRESS), PHP records progress metadata in the session under a key built from session.upload_progress.prefix (default upload_progress_) plus the value the client posted for that field. The client controls part of the session key.
The write happens during request parsing, before any application code runs, and it repeats as the upload streams in, governed by session.upload_progress.freq (default 1%) and session.upload_progress.min_freq (default one second). session.upload_progress.cleanup, also on by default, removes the progress data once the POST has been fully read.
The PHP manual carries a standing warning about the feature: the client-supplied file name and field name are written to the session store without validation and may contain PHP code, which makes any local file inclusion bug in the application trivial to exploit. Upload progress is one of the few mechanisms that lets a remote client put strings of its choosing into session storage before the application has any say.
PHP bug #71101: a ten-year-old warning
This combination has been on the project’s books for a decade. In December 2015, a researcher filed bug #71101, titled “serialize_handler must not be switched for existing sessions,” with a working demonstration. Upload progress writes attacker-shaped data into the session under one handler, the script switches handlers with ini_set(), and session_start() then parses the stored bytes with the wrong format. The proof of concept padded the progress field’s value and appended a serialized object, O:3:"obj":0:{}, whose __destruct() method ran when the misparsed session loaded. The reporter also noted that the cleanup feature was no obstacle, because a large upload keeps the progress data alive long enough for a concurrent request to read it.
Stas Malyshev’s response set the project’s position for the next ten years. Switching serializers mid-script was an explicit and mistaken action by the script, PHP could not reasonably prevent someone from writing session data with one serializer and reading it with another, and the report was treated as a documentation matter and not a security bug. It survives on the tracker today classified as a documentation bug.
The exact conditions that make a PHP application vulnerable
CVE-2026-115560 occupies exactly this territory, and PHP’s advisory specifies the direction of the switch. An application is exposed only if all three of these hold:
- Its configuration sets
session.serialize_handlertophp_binaryorphp_serialize. - Its code switches the handler to
phpat runtime withini_set()before callingsession_start(). - Session upload progress is still enabled, which it is by default.
Under those conditions, progress data written in one format during request parsing is parsed as the php format when the session opens. A pipe character embedded in the attacker-influenced portion of the stored bytes stops being string content and becomes the key/value boundary. Everything after it is handed to PHP’s unserialization machinery as a value. That is the entry point for the well-known PHP object injection class, where the impact depends on which classes the application and its dependencies have loaded and what their magic methods do.
One caveat belongs in any honest account. PHP has not yet published the root cause, and as The Hacker News has noted, the project has not said whether this issue shares a cause with CVE-2026-109619, which also involves upload progress but is a memory-safety bug. The published conditions line up with a hazard the project has documented since 2015. Thursday’s full advisory will say what the engine actually gets wrong.
Who is not affected
The narrowness is genuine. A site that uses the default php handler everywhere is outside the conditions. So is a site that configures php_serialize and never touches it at runtime, because the write and the read agree. PHP states explicitly that applications which never change the serialize handler at runtime can keep upload progress enabled.
How to audit your code for runtime serialize handler switches
The exposed population is the intersection of a non-default configured handler and a runtime switch back to php, and that switch can hide in places a casual review misses. Because session.serialize_handler is an INI_ALL directive, it can be changed through ini_set() and also through the options array passed to session_start() itself, and a Composer dependency can do either on the application’s behalf. The 2015 bug report cited Zend Framework’s session component as an example of code that sets the serializer mid-script.
A useful audit searches the vendor tree as well as first-party code, for both ini_set('session.serialize_handler' calls and 'serialize_handler' => entries in session options arrays.
How to mitigate CVE-2026-115560 before the patch
PHP’s guidance since October has been to set session.upload_progress.enabled=0 until the next regular bugfix release, which the project describes as full protection against this vector, and to restart every PHP worker so the setting takes effect. Nearly everything that can go wrong with that instruction is a placement problem.
Where to set session.upload_progress.enabled=0
The directive is INI_PERDIR, so application code cannot set it at all. ini_set() has no effect on it even in principle. PHP’s advisory says the setting must apply before request parsing, through php.ini, a conf.d drop-in, an FPM pool, or server configuration, and that operators should not rely on ini_set() or an FPM .user.ini file. Timing is the point. Upload progress runs while the multipart body is being parsed, so a value that only takes effect later in the request lifecycle arrives after the vulnerable write has already happened.
In an FPM pool, the admin-flag form is the strongest because the application cannot override it:
php_admin_flag[session.upload_progress.enabled] = off
Under Apache with mod_php, php_admin_flag in the vhost or server configuration does the same job. It cannot be used in .htaccess.
How to verify the setting through the web SAPI
Verification deserves the same care as placement. Running workers keep the configuration they started with, so the change means nothing until every worker has restarted. php -i on the command line reads the CLI’s configuration file, which on most distributions is a different file from the one FPM or Apache loads. The check has to happen through the web SAPI, whether via a pool config dump, a container inspection, or a temporary authenticated script that prints the effective value through a real web request.
What disabling upload progress breaks
The functional cost is small and specific. File uploads keep working, and only server-side progress tracking breaks. An application that renders a progress bar by polling $_SESSION loses that bar, while browser-side progress indicators carry on unaffected. Most applications never used the feature, which is why the October advisory for CVE-2026-109619 suggested keeping it off permanently where unused.
Teams that applied the setting in October and left it in place need to do nothing further for this CVE, per PHP’s own notice. Teams that treated it as temporary and reverted it after patching PHP2Shell have reopened the path and should close it again before Thursday.
The durable fix: pick one session serialize handler and stop switching
For any codebase where the audit finds a runtime handler switch, the setting closes this CVE but leaves the design flaw intact. The durable fix is the one bug #71101 has prescribed since 2015: choose one handler, set it in configuration, delete the runtime switch, and treat the change as a migration with a session reset so that old data written in the other format is never read back.
Once nothing depends on switching, php_admin_value[session.serialize_handler] = php_serialize locks the choice against reintroduction. Code that still calls ini_set() on a locked directive will silently fail to change it, so test that before deployment and not after.
PHP2Shell recap: the October flaws behind this release
The November announcement cannot be read sensibly without the event it trails. On 21 October at 14:00 UTC, PHP released 8.5.12, 8.4.27, 8.3.36, and 8.2.35 to fix CVE-2026-109618 and CVE-2026-109619, collectively named PHP2Shell. The security team rates both CVSS v4.0 9.2, and both enable unauthenticated remote code execution through specially crafted HTTP requests.
The official advisory names every installation serving web requests as at risk, including PHP-FPM, Apache with mod_php, php-cgi, FrankenPHP, and LiteSpeed. The highest risk sits on mod_php, where a demonstrated exploit triggers before any application code runs. Calif’s analysis traced the earliest affected code to PHP 5.4.0, released in 2012, so the vulnerable machinery had shipped for fourteen years.
CVE-2026-109618 and CVE-2026-109619: two bugs, two different mitigations
The two bugs are mechanically distinct, and the distinction decided which mitigations worked.
CVE-2026-109618 is out-of-memory corruption. When a request exhausts memory_limit, PHP’s historical bailout path uses longjmp() to jump straight out of the allocator, and it can do so while request-owned internal structures are only partially initialized. Request shutdown then walks memory and treats invalid state as valid. The attacker’s lever is timing, and the multipart parser supplies it through bodies with no usable declared length, floods of header lines inside a single part, empty file controls that do not count toward upload limits, and field names nested dozens of levels deep. No session and no particular form field is required.
CVE-2026-109619 is stale global state, a use-after-free. A request that dies at the wrong moment, through a fatal error, a timeout, or an OOM condition, leaves worker-global state pointing into freed memory. The next request the same worker handles reads that state before normal initialization resets it. Session upload progress is one of the confirmed readers, which is why the PHP_SESSION_UPLOAD_PROGRESS field saturates the exploit traffic. PHP’s advisory lists memory disclosure as a confirmed impact alongside code execution.
Disabling upload progress closed the confirmed session path for 109619 and did nothing for 109618, whose interim mitigation was memory_limit=-1 enforced so applications could not restore a finite limit. Updating was the only complete fix for either.
How the PHP2Shell disclosure fell apart
The disclosure itself fell apart in ways that compressed every defender’s timeline:
- 17 October: Amazon Threat Intelligence logged an attempt against its MadPot honeypots, four days before any public disclosure.
- 20 October: the two CVE IDs began circulating with a wrong release time and a wrong CVSS score of 10.0, and PHP pulled the release forward a day from 22 October. That evening, a proof-of-concept video published in error by Calif spread through social media.
- 21 October, 07:41 UTC: Chainguard broke the embargo and published fixed container images more than six hours early.
- 21 October, 07:43 UTC: Cloudflare reported early attacks.
- 21 October, 08:36 UTC: ELLIO’s sensor network recorded its first PHP2Shell request, five and a half hours before the fix was public. The tool’s user agent named CVE-2026-109618 while carrying the upload-progress field that belongs to CVE-2026-109619, a signature of exploit development driven by leaked material and not by the advisories.
- 26 October: CISA added both CVEs to its Known Exploited Vulnerabilities catalog with a federal remediation deadline of 29 October.
PHP 8.1 and older received no official releases, though the security team published minimal source backports for 7.4, 8.0, and 8.1. Distributions and LTS vendors shipped backported packages that keep their PHP version numbers and change only the package release, which is why checking a vendor changelog for the CVE string matters more than checking phpversion() on those systems.
PHP2Shell exploitation in the wild: limited on the open web, severe on uniform stacks
A month of telemetry has produced a split verdict on PHP2Shell, and it bears directly on how to read Thursday’s “uncommon setups” caveat.
Exploitation on the open web
On the heterogeneous open web, exploitation has mostly failed. Sansec’s analysis found that public proofs of concept generally do not work against default installations, and that many quietly require a local file inclusion bug in the target application. Wiz and CrowdStrike reported no end-to-end success in their own telemetry. watchTowr, Adel Karimi, and GreyNoise logged real shells on honeypots running deliberately favorable single-worker mod_php configurations, and Trail of Bits confirmed working exploits against pre-patch releases in the lab.
As CrowdStrike put it in remarks carried by The Hacker News, “exploit developers are unlikely to create a single universal exploit that works reliably across all affected PHP deployments.” The heap work depends on the SAPI, the memory limit, the build, and the architecture, and the address-leak stage fails often enough that attempted exploitation and demonstrated compromise remain different categories.
The tooling ecosystem is real all the same. Hunt.io reported on 30 October that its open-directory hunting had identified 616 PHP2Shell-related files spanning shared exploit kits, cloned PoCs, custom heap exploits, scanners, and post-exploitation tooling. One ASLR-bypass kit was byte-identical across four hosts, with lab logs showing execution as www-data. The Hacker News reports that underground forum participants were seeking exploits and debating prerequisites and whether circulating PoCs worked.
PAN-OS firewalls rooted in under fifteen minutes
Against a uniform stack, the reliability argument inverts, and that is where the confirmed damage occurred. Dream Research documented a campaign by suspected Chinese attackers, active as early as 23 October according to The Register, that rooted 25 servers running Palo Alto Networks PAN-OS management interfaces. Those interfaces expose one consistent PHP 8.0.30 build through the appweb server. The recovered exploit was custom and non-public, and its four stages read like a textbook of the bug class:
- Roughly 383 MB of crafted multipart requests groom the allocator into a predictable layout.
- A second request forges a stale session ID length to trigger an out-of-bounds read. The leaked pointer returns in the
Set-Cookieheader, exposing the base address oflibphp.soand defeating ASLR. - Another 500 MB of memory pressure leaves a stale reference the attacker can forge.
- A final request plants a HashTable entry in the freed region whose
pDestructorcallback points atzif_system, PHP’s internalsystem()function, so the cleanup walk executes the attacker’s command asnobody.
SELinux confines that context, so the same request chains CVE-2026-46300, the Linux kernel flaw nicknamed Fragnesia. It uses page-cache writes to overwrite the 774-byte /etc/pam.d/su with pam_permit.so, after which su root requires no password. Unauthenticated HTTPS to persistent root took under fifteen minutes. Unit 42 independently verified the attacker’s tooling and results, and Palo Alto Networks confirmed active exploitation against internet-exposed management interfaces on 28 October. CISA added Fragnesia to its KEV catalog the same day, noting the chaining explicitly.
The post-compromise activity reaches beyond the firewall. After rooting the devices, the attackers deployed web shells, opened reverse SSH tunnels, obtained an LDAP service account password stored on the firewall, and ran password spraying and reconnaissance against Active Directory, according to Dream’s findings as summarized by Field Effect. The campaign compromised 24 internet-facing firewalls and then an internal firewall management server, reached through a persistent tunnel, in a US government-affiliated environment. Targets spanned the US, Japan, Taiwan, and South Korea, and The Register reports the attackers “likely still” hold persistent remote access. A firewall that authenticates users against a directory holds credentials that can enumerate it, which is why a PHP bug in a management interface ends as an identity problem.
Check Point gateways, the TSGA backdoor, and the destroy_v6 wiper
Check Point documented its own campaign days later. According to Check Point Research, attackers exploited PHP2Shell in the Mobile Access portals of unpatched Security Gateways starting 30 October. They escalated from the portal service account to root through CVE-2026-123039, a local privilege-escalation flaw in the Gaia DynamicCLI interface, and deployed PHP webshells in the portal’s template directory, followed by the persistent TSGA backdoor. TSGA launched as /tmp/CPconfigdaemon and relocated into boot persistence as slot_CPconfigdaemon.
TSGA carries an embedded shared library, TSProxy, written to /lib/libcpfwcommon.so and injected into appliance processes. There it intercepts networking functions to service specially marked attacker connections while ordinary traffic continues. Both components share code, configuration, and cryptographic material with the PhiliKit framework previously documented against Ivanti appliances.
Check Point’s advisory puts the compromise count at a couple of dozen unpatched systems in a single region, with exploitation observed through 4 November. The first wave included destructive activity: lateral movement to a VMware ESXi host over SSH, execution of the destroy_v6 wiper, and politically themed DREAM_ANNEXATION.txt notes demanding no payment. Check Point declines high-confidence attribution and notes that false-flag scenarios remain plausible. The timeline is the uncomfortable detail. A hotfix had been available since 23 October, a week before the first wave, and every compromised system had not taken it.
Why “uncommon configuration” is not the same as low risk
None of this activity involves CVE-2026-115560, which has no reported exploitation and a much narrower trigger. What the month does show is how the word “uncommon” fails in practice. It describes a population, and across millions of deployments the configured-handler-plus-runtime-switch combination genuinely is rare. It never described any particular fleet.
October showed what happens when a rare but uniform configuration meets a motivated operator. A bug that mostly crashed workers on the open web became a fifteen-minute root chain against appliances that all ran the same build. The teams that should take Thursday most seriously are the ones whose audit turns up a non-default serialize handler, because for them the advisory’s caveat does not apply.
PHP security update checklist before 14:00 UTC on Thursday
The priority order follows from the record:
- Update any internet-facing PHP still below the October fixes, or without a distribution backport. PHP2Shell sits in the KEV catalog and has rooted firewalls, so these updates should not wait for Thursday’s releases.
- Set
session.upload_progress.enabled=0in server-level configuration and not in code. Restart every worker and verify the effective value through the web SAPI, not the CLI. - Run the handler audit across first-party code and the vendor tree before the release, so that when the full advisory lands with affected versions and the root cause, “are we in scope” is already answered.
- On PHP 8.1 and older, check the vendor changelog for the CVE string instead of trusting the version number.
- Watch the changelogs for one upgrade wrinkle from October. PHP 8.4.27 and 8.5.12 shipped a SimpleXML crash regression, tracked as php-src issue #24488 and traced by developers to a separate garbage-collector fix and not to the security patches. A correction was merged but unreleased as of late October.
- Where probing is suspected on existing servers, capture worker memory before restarting. Google Cloud’s guidance, written with Mandiant input, adds this forensic step because the restart that removes the vulnerable code also removes the evidence.
What to do when the PHP releases land
When the releases appear inside their thirty-minute window, read the full CVE-2026-115560 advisory, upgrade, restart, and verify. Only then decide whether upload progress needs to come back on at all. The October advisory already suggested leaving it off permanently where unused, and the feature’s decade-old documentation warning about unvalidated client data in session storage makes a reasonable case for retiring it from baseline images regardless of this CVE.
PHP has earned the right to schedule this fix instead of sprinting it, and the absence of exploitation against CVE-2026-115560 so far suggests the judgment was sound. A critical flaw that needs an uncommon setup is low risk only for deployments that lack that setup, and the only way to learn which side a server falls on is to read its configuration before someone else does.
Frequently asked questions about the PHP security release
When will PHP release the November 2026 security fixes?
The releases are scheduled for Thursday, 19 November 2026, between 14:00 and 14:30 UTC. PHP 8.6.0 is planned for general availability the same day.
Which PHP versions are affected?
The advisory says all supported PHP versions are affected, which covers the 8.2 through 8.5 branches. Fixed version numbers and affected-version ranges will be published with the releases. PHP 8.2 reaches end of life on 31 December 2026.
How do I mitigate CVE-2026-115560 before the patch?
Set session.upload_progress.enabled=0 in php.ini, a conf.d drop-in, an FPM pool, or server configuration. Do not rely on ini_set() or .user.ini. Restart every PHP worker and verify the value through the web SAPI. Applications that never switch the session serialize handler at runtime can keep upload progress enabled.
Is CVE-2026-115560 being exploited?
No exploitation of CVE-2026-115560 has been reported. The October PHP2Shell flaws (CVE-2026-109618 and CVE-2026-109619) are a different story: both are in CISA’s Known Exploited Vulnerabilities catalog.







